@hawkeyexl/manni 0.0.0-bootstrap.0 → 0.2.0

package/dist/chunk-OXH2ZM7E.js

@@ -0,0 +1,1050 @@
+#!/usr/bin/env node
+import {
+  COMMON_FORMATS,
+  COMMON_FORMAT_LIST,
+  DEFAULT_VENDOR_DIR,
+  DocmetaError,
+  FILL_FORMATS,
+  FILL_FORMAT_LIST,
+  OMITTED_WHEN_CLEAN,
+  QUERY_FORMATS,
+  QUERY_FORMAT_LIST,
+  REPORT_FORMATS,
+  REPORT_FORMAT_LIST,
+  ToolError,
+  getSchemasInfo,
+  isCommonFormat,
+  isFillFormat,
+  isMachineFormat,
+  isParamName,
+  isQueryFindingsFormat,
+  isQueryFormat,
+  isReportFormat,
+  package_default,
+  palette,
+  programName,
+  render,
+  renderFill,
+  renderGet,
+  renderQuery,
+  renderQueryCsv,
+  rowsToFindings,
+  runFill,
+  runGet,
+  runInferSchema,
+  runQuery,
+  runValidate,
+  runVendorSchema,
+  setProgramName,
+  shouldColor,
+  supportedExtensions,
+  toJsonText
+} from "./chunk-2OALUJV2.js";
+
+// src/shared/run.ts
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { CommanderError } from "commander";
+function fail(err) {
+  const msg = err instanceof ToolError ? err.message : `Unexpected error: ${err.message}`;
+  process.stderr.write(`${programName()}: ${msg}
+`);
+  process.exit(2);
+}
+async function runProgram(program, argv = process.argv) {
+  setProgramName(program.name());
+  try {
+    await program.parseAsync(argv);
+  } catch (err) {
+    if (err instanceof CommanderError) {
+      process.exitCode = err.exitCode === 0 ? 0 : 2;
+      return;
+    }
+    throw err;
+  }
+}
+function isMainModule(moduleUrl) {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  try {
+    return realpathSync(entry) === fileURLToPath(moduleUrl);
+  } catch {
+    return false;
+  }
+}
+function runIfMain(moduleUrl, build) {
+  if (!isMainModule(moduleUrl)) return;
+  runProgram(build()).catch(fail);
+}
+
+// src/meta/cli.ts
+import { existsSync } from "node:fs";
+import { basename, extname, relative, resolve as resolvePath } from "node:path";
+import { Command, Option } from "commander";
+import picomatch from "picomatch";
+
+// src/meta/reporters/infer.ts
+var OUTLIERS_SHOWN = 5;
+var ENUM_SHOWN = 3;
+var SAMPLE_WIDTH = 46;
+function count(n) {
+  return n.toLocaleString("en-US");
+}
+function percent(n) {
+  return `${n.toFixed(1)}%`;
+}
+function truncate(text, width) {
+  return text.length <= width ? text : `${text.slice(0, width - 1)}\u2026`;
+}
+function sampleCell(key) {
+  if (key.enumValues) {
+    const shown = key.enumValues.slice(0, ENUM_SHOWN).map((v) => typeof v === "string" ? v : JSON.stringify(v));
+    if (key.enumValues.length > ENUM_SHOWN) shown.push("\u2026");
+    return truncate(shown.join(" | "), SAMPLE_WIDTH);
+  }
+  if (key.sample === void 0) return "";
+  return truncate(toJsonText(key.sample) ?? "", SAMPLE_WIDTH);
+}
+function typesCell(key) {
+  if (key.types.length > 1) {
+    return key.types.map((t) => `${t.type} \xD7${count(t.count)}`).join(", ");
+  }
+  if (key.enumValues) return `${key.dominantType} (${key.enumValues.length} enum)`;
+  if (key.format) return `${key.dominantType} (${key.format})`;
+  return key.dominantType;
+}
+function renderInfer(result, opts = {}) {
+  const c = palette(opts.color ?? false);
+  const lines = [];
+  const headline = [
+    `${count(result.filesScanned)} file${result.filesScanned === 1 ? "" : "s"} scanned`
+  ];
+  headline.push(
+    `${count(result.filesWithoutMetadata)} with no metadata block`
+  );
+  if (result.unreadable.length > 0) {
+    headline.push(`${count(result.unreadable.length)} unreadable`);
+  }
+  if (result.gitignoreSkipped > 0) {
+    headline.push(`${count(result.gitignoreSkipped)} skipped by .gitignore`);
+  }
+  lines.push(headline.join(c.dim(" \xB7 ")));
+  if (result.keys.length === 0) {
+    lines.push("", c.dim("No metadata keys found."));
+    return lines.join("\n");
+  }
+  const rows = result.keys.map((k) => ({
+    key: k.key,
+    coverage: percent(k.coverage),
+    types: typesCell(k),
+    sample: sampleCell(k)
+  }));
+  const width = (pick, head) => Math.max(head.length, ...rows.map((r) => pick(r).length));
+  const wKey = width((r) => r.key, "key");
+  const wCov = width((r) => r.coverage, "coverage");
+  const wTypes = width((r) => r.types, "types");
+  lines.push(
+    "",
+    c.dim(
+      `${"key".padEnd(wKey)}  ${"coverage".padStart(wCov)}  ${"types".padEnd(wTypes)}  sample`
+    )
+  );
+  for (const r of rows) {
+    lines.push(
+      `${c.cyan(r.key.padEnd(wKey))}  ${r.coverage.padStart(wCov)}  ${r.types.padEnd(wTypes)}  ${c.dim(r.sample)}`
+    );
+  }
+  if (result.hiddenByMinCoverage > 0) {
+    lines.push(
+      "",
+      c.dim(
+        `${count(result.hiddenByMinCoverage)} key(s) below --min-coverage are not shown.`
+      )
+    );
+  }
+  const withOutliers = result.keys.filter((k) => k.outlierCount > 0);
+  if (withOutliers.length > 0) {
+    lines.push(
+      "",
+      c.bold("Type outliers \u2014 these are data errors, not a union:")
+    );
+    for (const k of withOutliers) {
+      for (const o of k.outliers.slice(0, OUTLIERS_SHOWN)) {
+        const at = o.line === void 0 ? o.file : `${o.file}:${o.line}`;
+        lines.push(`  ${k.key}  ${at}  ${o.type} (expected ${k.dominantType})`);
+      }
+      const rest = k.outlierCount - Math.min(k.outliers.length, OUTLIERS_SHOWN);
+      if (rest > 0) lines.push(c.dim(`  ${k.key}  \u2026and ${count(rest)} more`));
+    }
+  }
+  for (const u of result.unreadable) {
+    lines.push("", `${c.yellow("!")} ${u.file}: ${u.message}`);
+  }
+  if (result.out !== void 0) {
+    const properties = Object.keys(result.draft.properties ?? {}).length;
+    lines.push(
+      "",
+      `Wrote a draft schema to ${c.cyan(result.out)} \u2014 ${count(properties)} propert${properties === 1 ? "y" : "ies"}, nothing required.`,
+      c.dim(
+        "Nothing is required on purpose: what your docset contains is not the same as what your standard should demand. Promote a key with `validate --write-baseline` behind it."
+      )
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/meta/cli.ts
+function collect(value, prev) {
+  return prev.concat([value]);
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+function resolveColor(program) {
+  const noColor = program.opts().color === false;
+  return shouldColor({ noColor, isTTY: process.stdout.isTTY });
+}
+function formatFor(command, own) {
+  if (command.getOptionValueSource("format") === "cli") return own;
+  const parent = command.parent;
+  if (parent && parent.getOptionValueSource("format") === "cli") {
+    return parent.opts().format;
+  }
+  return own;
+}
+function assertCommonFormat(value) {
+  const format = String(value);
+  if (!isCommonFormat(format)) {
+    throw new DocmetaError(
+      `Unknown --format "${format}". Use ${COMMON_FORMAT_LIST}.`
+    );
+  }
+  return format;
+}
+var STDIN = "-";
+function looksLikePath(token, cwd, alone) {
+  if (token === STDIN) return false;
+  const scan = picomatch.scan(token);
+  const shaped = /[\\/]/.test(token) || extname(token) !== "" || scan.isGlob;
+  if ((shaped || alone) && existsSync(resolvePath(cwd, token))) return true;
+  if (token.includes(",") || token.startsWith("/")) return false;
+  if (scan.isGlob) return true;
+  const ext = extname(token).toLowerCase();
+  if (ext !== "" && supportedExtensions().includes(ext)) return true;
+  return /[\\/]/.test(token);
+}
+function resolveGetInputs(fieldsArg, pathsArg, fieldsOption, cwd) {
+  const flag = typeof fieldsOption === "string" ? fieldsOption : void 0;
+  if (flag === void 0 && fieldsArg !== void 0 && looksLikePath(fieldsArg, cwd, pathsArg.length === 0)) {
+    throw new DocmetaError(
+      `"${fieldsArg}" looks like a path, not a field list. Pass fields first (manni meta get title ${fieldsArg}) or use --fields.`
+    );
+  }
+  const source = flag ?? (fieldsArg === STDIN ? void 0 : fieldsArg);
+  const fields = source === void 0 ? [] : splitList(source);
+  if (fields.length === 0) {
+    throw new DocmetaError(
+      "Specify at least one field to get. Pass fields first (manni meta get title docs/a.md) or use --fields."
+    );
+  }
+  const paths = fieldsArg !== void 0 && (flag !== void 0 || fieldsArg === STDIN) ? [fieldsArg, ...pathsArg] : pathsArg;
+  return { fields, paths };
+}
+function resolveQueryInputs(sqlArg, pathsArg, queryOption, cwd, sqlOptional = false) {
+  const flag = typeof queryOption === "string" ? queryOption : void 0;
+  if (flag === void 0 && sqlArg !== void 0 && // A token with whitespace is never a path: every real statement has
+  // spaces, and without this test `SELECT count(*) FROM docs` reads as a
+  // *glob* — picomatch parses `(*)` as an extglob — the one SQL shape the
+  // comma test inside looksLikePath does not catch.
+  !/\s/.test(sqlArg) && // With SQL optional there is no "forgot the statement" reading to
+  // protect, so a shapeless token that really exists on disk is a path
+  // even when other paths follow — hence `alone` is forced on.
+  looksLikePath(sqlArg, cwd, sqlOptional || pathsArg.length === 0)) {
+    if (sqlOptional) return { sql: "", paths: [sqlArg, ...pathsArg] };
+    throw new DocmetaError(
+      `"${sqlArg}" looks like a path, not SQL. Pass the SQL first (manni meta query "SELECT _path FROM docs" ${sqlArg}) or use --query.`
+    );
+  }
+  const source = flag ?? (sqlArg === STDIN ? void 0 : sqlArg);
+  const sql = source?.trim() ?? "";
+  if (sql === "" && !sqlOptional) {
+    throw new DocmetaError(
+      'Specify SQL to run. Pass it first (manni meta query "SELECT _path FROM docs" docs/) or use --query.'
+    );
+  }
+  const paths = sqlArg !== void 0 && (flag !== void 0 || sqlArg === STDIN) ? [sqlArg, ...pathsArg] : pathsArg;
+  return { sql, paths };
+}
+function parseQueryParams(raw) {
+  const params = /* @__PURE__ */ Object.create(null);
+  for (const item of raw) {
+    const typed = item.indexOf(":=");
+    const plain = item.indexOf("=");
+    const useTyped = typed !== -1 && (plain === -1 || typed < plain);
+    const at = useTyped ? typed : plain;
+    if (at <= 0) {
+      throw new DocmetaError(
+        `--param "${item}" is not name=value. Use name=value to bind a string, or name:=json for a typed value.`
+      );
+    }
+    const name = item.slice(0, at);
+    const bare = /^[$:@]/.test(name) ? name.slice(1) : name;
+    if (!isParamName(bare)) {
+      throw new DocmetaError(
+        `--param name "${name}" cannot be bound: a SQL named parameter is letters, digits, and underscores, starting with a letter or underscore.`
+      );
+    }
+    const value = item.slice(at + (useTyped ? 2 : 1));
+    if (!useTyped) {
+      params[name] = value;
+      continue;
+    }
+    try {
+      params[name] = JSON.parse(value);
+    } catch {
+      throw new DocmetaError(
+        `--param ${name}:=${value} is not valid JSON. Quote a string \u2014 --param '${name}:="${value}"' \u2014 or drop the colon (--param ${name}=${value}) to bind it as a string.`
+      );
+    }
+  }
+  return params;
+}
+function renderQueryFindings(run, format) {
+  if (run.changes) {
+    throw new DocmetaError(
+      `--format ${format} renders result rows with a \`path\` column; this statement produced pending changes, not rows. Use pretty or json for the change preview.`
+    );
+  }
+  const results = [...rowsToFindings(
+    "query",
+    run.columns,
+    run.rows
+  )].map(([file, errors]) => ({
+    file,
+    format: "query",
+    ok: false,
+    schemas: [],
+    errors
+  }));
+  const summary = {
+    files: results.length,
+    passed: 0,
+    failed: results.length,
+    errors: results.reduce((n, r) => n + r.errors.length, 0)
+  };
+  const text = render(format, results, summary, {
+    frame: run.frame,
+    classname: "manni.query",
+    onNotice: notice
+  });
+  if (text.length > 0 || !OMITTED_WHEN_CLEAN.has(format)) {
+    process.stdout.write(`${text}
+`);
+  }
+  process.exitCode = run.rows.length > 0 ? 1 : 0;
+}
+var COMMAND_NAMES = ["validate", "get", "query", "fill", "schemas"];
+function editDistance(a, b) {
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const row = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      row.push(
+        Math.min(
+          (row[j - 1] ?? 0) + 1,
+          (prev[j] ?? 0) + 1,
+          (prev[j - 1] ?? 0) + cost
+        )
+      );
+    }
+    prev = row;
+  }
+  return prev[b.length] ?? 0;
+}
+function suggestCommand(token, cwd) {
+  if (token === void 0 || token === "-") return;
+  if (/[\\/.]/.test(token)) return;
+  if (picomatch.scan(token).isGlob) return;
+  if (existsSync(resolvePath(cwd, token))) return;
+  const near = COMMAND_NAMES.map(
+    (name) => [name, editDistance(token.toLowerCase(), name)]
+  ).filter(([, d]) => d > 0 && d <= 2).sort((x, y) => x[1] - y[1]);
+  const best = near[0];
+  if (!best) return;
+  throw new DocmetaError(
+    `Unknown command "${token}". Did you mean "${best[0]}"?`
+  );
+}
+function configOption(value) {
+  if (value === false) return { noConfig: true };
+  return typeof value === "string" ? { configPath: value } : {};
+}
+function reportConfig(toStdout, cwd) {
+  return (info) => {
+    const where = (relative(cwd, info.dir) || ".").replace(/\\/g, "/");
+    const line = `Using ${basename(info.path)} (${where})
+`;
+    (toStdout ? process.stdout : process.stderr).write(line);
+  };
+}
+function notice(message) {
+  process.stderr.write(`${programName()}: ${message}
+`);
+}
+function gitignoreFlag(value) {
+  return value === false ? false : void 0;
+}
+function splitList(value) {
+  return value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function numeric(name, value, min, max) {
+  if (value === void 0) return;
+  if (!Number.isFinite(value) || value < min || value > max) {
+    throw new DocmetaError(
+      `${name} must be a number between ${min} and ${max}, got ${value}.`
+    );
+  }
+}
+function buildProgram() {
+  const program = new Command();
+  program.name("meta").description(
+    "Validate the presence and format of document metadata against JSON Schema."
+  ).version(package_default.version, "-V, --version").option("--no-color", "disable colored output").showHelpAfterError("(add --help for usage)").exitOverride();
+  program.command("validate", { isDefault: true }).description("Validate metadata in the given files/dirs/globs").argument(
+    "[paths...]",
+    "files, directories, or globs to validate (use - for stdin)"
+  ).option(
+    "-s, --schema <ref>",
+    "schema to validate against; repeatable; overrides $schema/config",
+    collect,
+    []
+  ).option("--ext <list>", "comma-separated extensions for directory walks").option("--exclude <glob>", "glob to exclude; repeatable", collect, []).option("--as <format>", "force an input format (e.g. markdown, mdx)").option(
+    "-f, --format <format>",
+    `output: ${REPORT_FORMATS.join(" | ")}`,
+    "pretty"
+  ).option("-c, --config <path>", "path to a manni config file").option("--no-config", "ignore any discovered config file").option("-q, --quiet", "in pretty output, hide passing files").option("--allow-empty", "treat zero matched files as success").option("--no-gitignore", "check files .gitignore covers").option(
+    "--offline",
+    "never fetch a remote schema; resolve URL refs from the schema cache"
+  ).addOption(
+    new Option(
+      "--baseline [path]",
+      "compare against a baseline; fail only on new findings"
+    )
+  ).addOption(
+    new Option(
+      "--write-baseline [path]",
+      "record current findings as the baseline, then exit 0 (stdin findings are not recorded and still fail)"
+    )
+  ).option("--no-baseline", "ignore a baseline configured by `baseline:`").option(
+    "--no-checks",
+    "skip the corpus checks configured by `checks:` for this run"
+  ).addHelpText(
+    "after",
+    [
+      "",
+      "Examples:",
+      "  manni meta validate docs/                       # walk a directory",
+      '  manni meta validate "**/*.md" -f github         # CI annotations',
+      '  manni meta validate "**/*.md" -f sarif > o.sarif # code scanning',
+      "  manni meta validate page.md -s google:okf:0.1 -s ./my.schema.json",
+      "  cat page.md | manni meta validate - --as markdown",
+      "  manni meta validate --write-baseline            # record today's backlog",
+      "  manni meta validate --baseline                  # fail only on new findings"
+    ].join("\n")
+  ).action(
+    async (paths, options, command) => {
+      try {
+        suggestCommand(paths[0], process.cwd());
+        const format = options.format;
+        if (!isReportFormat(format)) {
+          throw new DocmetaError(
+            `Unknown --format "${format}". Use ${REPORT_FORMAT_LIST}.`
+          );
+        }
+        const exts = options.ext ? splitList(options.ext) : void 0;
+        const stdinContent = paths.includes("-") ? await readStdin() : void 0;
+        const { results, summary, frame } = await runValidate({
+          inputs: paths,
+          cliSchemas: options.schema,
+          exts,
+          exclude: options.exclude,
+          as: options.as,
+          ...configOption(options.config),
+          onConfigLoaded: reportConfig(
+            !isMachineFormat(format),
+            process.cwd()
+          ),
+          stdinContent,
+          // `undefined` rather than `false` when the flag is absent, so config
+          // `allowEmpty:` still wins (the cores do `opts ?? config`).
+          allowEmpty: options.allowEmpty ? true : void 0,
+          respectGitignore: gitignoreFlag(options.gitignore),
+          // `undefined` rather than `false` when absent, so config `offline:`
+          // still decides.
+          offline: options.offline ? true : void 0,
+          onNotice: notice,
+          // `--baseline` and `--no-baseline` share one commander attribute, the
+          // same three-state `undefined | string | false` split as `-c` /
+          // `--no-config`: absent leaves the config in charge, a string names a
+          // file, `false` suppresses a configured one for this run.
+          baseline: options.baseline,
+          writeBaseline: options.writeBaseline,
+          // Like `gitignore`: only the explicit `--no-checks` travels, so
+          // absence stays "run them when the corpus rule allows".
+          checks: options.checks ? void 0 : false
+        });
+        const color = resolveColor(command.parent ?? command);
+        const text = render(format, results, summary, {
+          color,
+          quiet: Boolean(options.quiet),
+          // Non-presentational: SARIF needs to know where the run stood before
+          // it can name a file the way the repository does.
+          frame,
+          onNotice: notice
+        });
+        if (text.length > 0 || !OMITTED_WHEN_CLEAN.has(format)) {
+          process.stdout.write(`${text}
+`);
+        }
+        process.exitCode = summary.failed > 0 ? 1 : 0;
+      } catch (err) {
+        fail(err);
+      }
+    }
+  );
+  program.command("get").description("Print metadata field values from the given files/dirs/globs").argument(
+    "[fields]",
+    "comma-separated metadata fields to print, unless --fields is given"
+  ).argument(
+    "[paths...]",
+    "files, directories, or globs to read (use - for stdin)"
+  ).option(
+    "--fields <list>",
+    "comma-separated metadata fields to print; every positional is then a path"
+  ).option("--ext <list>", "comma-separated extensions for directory walks").option("--exclude <glob>", "glob to exclude; repeatable", collect, []).option("--as <format>", "force an input format (e.g. markdown, mdx)").option(
+    "-f, --format <format>",
+    `output: ${COMMON_FORMATS.join(" | ")}`,
+    "pretty"
+  ).option("-c, --config <path>", "path to a manni config file").option("--no-config", "ignore any discovered config file").option(
+    "-q, --quiet",
+    "in pretty output, hide files where every requested field is unset"
+  ).option("--allow-empty", "treat zero matched files as success").option("--no-gitignore", "read files .gitignore covers").option(
+    "--offline",
+    "accepted and ignored: get loads no schema, so there is nothing to fetch"
+  ).addHelpText(
+    "after",
+    [
+      "",
+      "Examples:",
+      "  manni meta get title,type docs/intro.md",
+      "  manni meta get --fields title,type docs/intro.md",
+      "  manni meta get author.name,/author/email docs/intro.md",
+      '  manni meta get type "**/*.md" -f json',
+      "  cat page.md | manni meta get title - --as markdown"
+    ].join("\n")
+  ).action(
+    async (fieldsArg, pathsArg, options, command) => {
+      try {
+        const format = assertCommonFormat(options.format);
+        const { fields, paths } = resolveGetInputs(
+          fieldsArg,
+          pathsArg,
+          options.fields,
+          process.cwd()
+        );
+        const exts = options.ext ? splitList(options.ext) : void 0;
+        const stdinContent = paths.includes("-") ? await readStdin() : void 0;
+        const results = await runGet({
+          fields,
+          inputs: paths,
+          as: options.as,
+          exclude: options.exclude,
+          exts,
+          ...configOption(options.config),
+          onConfigLoaded: reportConfig(format === "pretty", process.cwd()),
+          stdinContent,
+          allowEmpty: options.allowEmpty ? true : void 0,
+          respectGitignore: gitignoreFlag(options.gitignore),
+          offline: options.offline ? true : void 0,
+          onNotice: notice
+        });
+        switch (format) {
+          case "json":
+            process.stdout.write(`${JSON.stringify(results, null, 2)}
+`);
+            break;
+          case "pretty": {
+            const text = renderGet(results, fields, {
+              color: resolveColor(command.parent ?? command),
+              quiet: Boolean(options.quiet)
+            });
+            if (text.length > 0) process.stdout.write(`${text}
+`);
+            break;
+          }
+          default: {
+            const unreachable = format;
+            throw new DocmetaError(
+              `Unknown --format ${JSON.stringify(unreachable)}. Use ${COMMON_FORMAT_LIST}.`
+            );
+          }
+        }
+        process.exitCode = results.some((r) => r.error !== void 0) ? 1 : 0;
+      } catch (err) {
+        fail(err);
+      }
+    }
+  );
+  program.command("query").description("Run SQL over the metadata of the given files/dirs/globs").argument("[sql]", "SQL to run against the `docs` table, unless --query is given").argument(
+    "[paths...]",
+    "files, directories, or globs to load (use - for stdin)"
+  ).option(
+    "--query <sql>",
+    "SQL to run against the `docs` table; every positional is then a path"
+  ).option(
+    "-s, --schema <ref>",
+    "schema set a DDL statement evolves; repeatable; replaces the per-file resolution for the DDL planner only",
+    collect,
+    []
+  ).option(
+    "--check",
+    "treat returned rows as findings: exit 1 if the query returns any"
+  ).option(
+    "--param <name=value>",
+    "bind a named SQL parameter ($name/:name/@name) as a string; name:=value parses the value as JSON; repeatable",
+    collect,
+    []
+  ).option(
+    "--db <path>",
+    "also write the built database to this file; SQL is then optional"
+  ).option(
+    "--dry-run",
+    "preview a mutating statement's diff without applying it (--check implies this)"
+  ).option("--ext <list>", "comma-separated extensions for directory walks").option("--exclude <glob>", "glob to exclude; repeatable", collect, []).option("--as <format>", "force an input format (e.g. markdown, mdx)").option(
+    "-f, --format <format>",
+    `output: ${QUERY_FORMATS.join(" | ")} (github, sarif, junit need --check)`,
+    "pretty"
+  ).option("-c, --config <path>", "path to a manni config file").option("--no-config", "ignore any discovered config file").option("--allow-empty", "treat zero matched files as success").option("--no-gitignore", "load files .gitignore covers").option(
+    "--offline",
+    "accepted and ignored: query resolves schemas from disk and built-ins, never the network"
+  ).addHelpText(
+    "after",
+    [
+      "",
+      "One row per file in a table named `docs`: your top-level metadata keys",
+      "as columns, plus _path, _format, _present, and _data (all metadata as",
+      "JSON, for json_each/->> reach into nested values).",
+      "",
+      "Examples:",
+      '  manni meta query "SELECT _path, title FROM docs WHERE draft = 1" docs/',
+      '  manni meta query "SELECT t.value tag, count(*) n FROM docs, json_each(docs.tags) t GROUP BY tag" docs/',
+      '  manni meta query --check "SELECT slug, count(*) n FROM docs GROUP BY slug HAVING n > 1" docs/',
+      '  manni meta query -f csv "SELECT _path, title, last_reviewed FROM docs" docs/ > stale.csv',
+      `  manni meta query --param author="O'Brien" "SELECT _path FROM docs WHERE author = \\$author" docs/`,
+      '  cat page.md | manni meta query "SELECT title FROM docs" - --as markdown',
+      "  manni meta query --db docs.db docs/       # export only; open with any SQLite UI"
+    ].join("\n")
+  ).action(
+    async (sqlArg, pathsArg, options, command) => {
+      try {
+        const format = options.format;
+        if (!isQueryFormat(format)) {
+          throw new DocmetaError(
+            `Unknown --format "${format}". Use ${QUERY_FORMAT_LIST}.`
+          );
+        }
+        if (isQueryFindingsFormat(format) && !options.check) {
+          throw new DocmetaError(
+            `--format ${format} renders findings, which only --check produces. Add --check, or use pretty, json, or csv.`
+          );
+        }
+        const { sql, paths } = resolveQueryInputs(
+          sqlArg,
+          pathsArg,
+          options.query,
+          process.cwd(),
+          typeof options.db === "string"
+        );
+        if (format === "csv" && sql === "") {
+          throw new DocmetaError(
+            "--format csv renders result rows, and a --db export without SQL produces none. Use pretty or json for the export summary."
+          );
+        }
+        if (isQueryFindingsFormat(format) && sql === "") {
+          throw new DocmetaError(
+            `--format ${format} renders findings, which need a statement to produce rows \u2014 a --db export without SQL has none. Pass the SQL, or drop --check -f ${format}.`
+          );
+        }
+        if (options.param.length > 0 && sql === "") {
+          throw new DocmetaError(
+            "--param needs a statement to bind into; a --db export without SQL references no parameters. Pass the SQL, or drop --param."
+          );
+        }
+        if (options.schema.length > 0 && sql === "") {
+          throw new DocmetaError(
+            "-s names the schema set DDL evolves; without SQL there is no statement to evolve it. Pass the SQL, or drop -s."
+          );
+        }
+        const params = parseQueryParams(options.param);
+        const exts = options.ext ? splitList(options.ext) : void 0;
+        const stdinContent = paths.includes(STDIN) ? await readStdin() : void 0;
+        const dryRun = Boolean(options.dryRun) || Boolean(options.check) || format === "csv";
+        const run = await runQuery({
+          sql,
+          db: options.db,
+          dryRun,
+          ...Object.keys(params).length > 0 ? { params } : {},
+          ...options.schema.length > 0 ? { schemas: options.schema } : {},
+          inputs: paths,
+          as: options.as,
+          exclude: options.exclude,
+          exts,
+          ...configOption(options.config),
+          onConfigLoaded: reportConfig(format === "pretty", process.cwd()),
+          stdinContent,
+          allowEmpty: options.allowEmpty ? true : void 0,
+          respectGitignore: gitignoreFlag(options.gitignore),
+          offline: options.offline ? true : void 0,
+          onNotice: notice
+        });
+        if (run.db && sql === "") {
+          process.stdout.write(
+            format === "json" ? `${JSON.stringify(run.db, null, 2)}
+` : `Wrote ${run.db.path} (${run.db.files} files, ${run.db.columns} columns)
+`
+          );
+          process.exitCode = 0;
+          return;
+        }
+        if (run.db) {
+          notice(`wrote ${run.db.path} (${run.db.files} files)`);
+        }
+        if (isQueryFindingsFormat(format)) {
+          renderQueryFindings(run, format);
+          return;
+        }
+        switch (format) {
+          case "csv":
+            if (run.changes) {
+              throw new DocmetaError(
+                "--format csv renders result rows; this statement produced changes, which have no tabular shape \u2014 nothing was applied. Use pretty or json to preview them, and run without -f csv to apply."
+              );
+            }
+            process.stdout.write(`${renderQueryCsv(run)}
+`);
+            break;
+          case "json":
+            process.stdout.write(
+              `${JSON.stringify(run.changes ?? run.rows, null, 2)}
+`
+            );
+            break;
+          case "pretty": {
+            const text = renderQuery(run, {
+              color: resolveColor(command.parent ?? command),
+              check: Boolean(options.check),
+              dryRun
+            });
+            if (text.length > 0) process.stdout.write(`${text}
+`);
+            break;
+          }
+          default: {
+            const unreachable = format;
+            throw new DocmetaError(
+              `Unknown --format ${JSON.stringify(unreachable)}. Use ${QUERY_FORMAT_LIST}.`
+            );
+          }
+        }
+        const findings = run.changes ? run.changes.length : run.rows.length;
+        process.exitCode = options.check && findings > 0 ? 1 : 0;
+      } catch (err) {
+        fail(err);
+      }
+    }
+  );
+  program.command("fill").description(
+    "Infer missing or invalid metadata and write values above the confidence threshold"
+  ).argument(
+    "[paths...]",
+    "files, directories, or globs to fill (use - for stdin)"
+  ).option(
+    "-s, --schema <ref>",
+    "schema to fill against; repeatable; overrides $schema/config",
+    collect,
+    []
+  ).option("--ext <list>", "comma-separated extensions for directory walks").option("--exclude <glob>", "glob to exclude; repeatable", collect, []).option("--as <format>", "force an input format (e.g. markdown, mdx)").option("--fields <list>", "comma-separated fields to fill").option("--confidence <n>", "minimum confidence to write (0-1)", parseFloat).option("--dry-run", "report proposals without writing them").option(
+    "--provider <name>",
+    "provider: auto (default), anthropic, openai, claude-cli, llama-cpp, mock"
+  ).option(
+    "--model <model>",
+    "model override; needs a named provider, from here or config"
+  ).option("--no-cache", "bypass the proposal cache").option(
+    "--local",
+    "run inference on this machine; refuses any hosted provider, claude-cli included"
+  ).option("--max-turns <n>", "stop after this many inference calls", parseFloat).option(
+    "--chunk-chars <n>",
+    "characters of document per call (default 12000)",
+    parseFloat
+  ).option("--concurrency <n>", "files inferred in parallel", parseFloat).option(
+    "-f, --format <format>",
+    `output: ${FILL_FORMATS.join(" | ")}`,
+    "pretty"
+  ).option("-c, --config <path>", "path to a manni config file").option("--no-config", "ignore any discovered config file").option(
+    "-q, --quiet",
+    "in pretty output, hide files with nothing written and nothing required left undone"
+  ).option("--allow-empty", "treat zero matched files as success").option("--no-gitignore", "fill files .gitignore covers").option(
+    "--offline",
+    "never fetch a remote schema; resolve URL refs from the schema cache"
+  ).addHelpText(
+    "after",
+    [
+      "",
+      "Examples:",
+      "  manni meta fill docs/ --dry-run                 # preview proposals",
+      "  manni meta fill docs/ --confidence 0.9          # only near-certain values",
+      "  manni meta fill page.md --fields description",
+      "  manni meta fill docs/ -f github                 # CI annotations",
+      "  cat page.md | manni meta fill - --as markdown   # filled doc to stdout"
+    ].join("\n")
+  ).action(async (paths, options, command) => {
+    try {
+      const format = options.format;
+      if (!isFillFormat(format)) {
+        throw new DocmetaError(
+          `Unknown --format "${format}". Use ${FILL_FORMAT_LIST}.`
+        );
+      }
+      numeric("--confidence", options.confidence, 0, 1);
+      numeric("--max-turns", options.maxTurns, 1, Number.MAX_SAFE_INTEGER);
+      numeric(
+        "--chunk-chars",
+        options.chunkChars,
+        1,
+        Number.MAX_SAFE_INTEGER
+      );
+      numeric("--concurrency", options.concurrency, 1, 64);
+      const exts = options.ext ? splitList(options.ext) : void 0;
+      const usingStdin = paths.includes(STDIN);
+      if (usingStdin && format === "github") {
+        throw new DocmetaError(
+          'Cannot use --format github with stdin ("-"): the filled document owns stdout, so the annotations would go to stderr, where GitHub ignores them. Pass file paths instead.'
+        );
+      }
+      const stdinContent = usingStdin ? await readStdin() : void 0;
+      const run = await runFill({
+        inputs: paths,
+        cliSchemas: options.schema,
+        exts,
+        exclude: options.exclude,
+        as: options.as,
+        ...configOption(options.config),
+        // With `-` the filled document owns stdout, so the notice is a
+        // diagnostic there just as the report is.
+        onConfigLoaded: reportConfig(
+          format === "pretty" && !usingStdin,
+          process.cwd()
+        ),
+        stdinContent,
+        allowEmpty: options.allowEmpty ? true : void 0,
+        respectGitignore: gitignoreFlag(options.gitignore),
+        offline: options.offline ? true : void 0,
+        onNotice: notice,
+        fields: options.fields ? splitList(options.fields) : void 0,
+        confidence: options.confidence,
+        dryRun: Boolean(options.dryRun),
+        provider: options.provider,
+        model: options.model,
+        cache: options.cache,
+        local: Boolean(options.local),
+        maxTurns: options.maxTurns,
+        chunkChars: options.chunkChars,
+        concurrency: options.concurrency,
+        includeContent: usingStdin
+      });
+      const color = resolveColor(command.parent ?? command);
+      const report = renderFill(format, run, {
+        color,
+        quiet: Boolean(options.quiet)
+      });
+      if (usingStdin) {
+        const filled = run.results[0]?.content;
+        if (filled != null) process.stdout.write(filled);
+        if (report.length > 0) process.stderr.write(`${report}
+`);
+      } else if (report.length > 0) {
+        process.stdout.write(`${report}
+`);
+      }
+      process.exitCode = run.summary.requiredSkipped > 0 || run.summary.errors > 0 ? 1 : 0;
+    } catch (err) {
+      fail(err);
+    }
+  });
+  const schemas = program.command("schemas").description("List built-in schemas and supported input formats").option(
+    "-f, --format <format>",
+    `output: ${COMMON_FORMATS.join(" | ")}`,
+    "pretty"
+  ).action((options, command) => {
+    try {
+      const format = assertCommonFormat(options.format);
+      const info = getSchemasInfo();
+      if (format === "json") {
+        process.stdout.write(`${JSON.stringify(info, null, 2)}
+`);
+        return;
+      }
+      const c = palette(resolveColor(command.parent ?? command));
+      const lines = [c.bold("Built-in schemas:")];
+      for (const b of info.builtins) {
+        lines.push(`  ${c.cyan(b.id)}  ${c.dim("\u2014")}  ${b.title}`);
+      }
+      lines.push("", c.bold("Input formats:"));
+      for (const f of info.formats) {
+        const tags = [
+          f.implemented ? c.green("implemented") : c.dim("planned")
+        ];
+        if (f.implemented) {
+          tags.push(f.writable ? c.green("writable") : c.dim("read-only"));
+        }
+        lines.push(
+          `  ${f.name} (${f.extensions.join(", ")})  [${tags.join(", ")}]`
+        );
+      }
+      process.stdout.write(`${lines.join("\n")}
+`);
+    } catch (err) {
+      fail(err);
+    }
+  });
+  schemas.command("infer").description(
+    "Report metadata coverage across a docset, and draft a schema from what is there"
+  ).argument(
+    "[paths...]",
+    "files, directories, or globs to scan (use - for stdin)"
+  ).option("--out <path>", "write the draft schema here").option(
+    "--min-coverage <pct>",
+    "hide keys below this coverage percentage",
+    parseFloat,
+    0
+  ).option("--ext <list>", "comma-separated extensions for directory walks").option("--exclude <glob>", "glob to exclude; repeatable", collect, []).option("--as <format>", "force an input format (e.g. markdown, mdx)").option(
+    "-f, --format <format>",
+    `output: ${COMMON_FORMATS.join(" | ")}`,
+    "pretty"
+  ).option("-c, --config <path>", "path to a manni config file").option("--no-config", "ignore any discovered config file").option("--allow-empty", "treat zero matched files as success").option("--no-gitignore", "scan files .gitignore covers").option(
+    "--offline",
+    "accepted and ignored: infer loads no schema and no provider"
+  ).addHelpText(
+    "after",
+    [
+      "",
+      "Examples:",
+      "  manni meta schemas infer docs/                  # what does this repo have?",
+      "  manni meta schemas infer docs/ --min-coverage 5 # drop the long tail",
+      "  manni meta schemas infer docs/ --out ./schemas/permissive.json",
+      "  manni meta schemas infer docs/ -f json",
+      "",
+      "Purely statistical and offline: no provider, no network, no model. The",
+      "draft never marks anything `required` \u2014 coverage is your decision to",
+      "make, not the tool's."
+    ].join("\n")
+  ).action(async (paths, options, command) => {
+    try {
+      const format = assertCommonFormat(formatFor(command, options.format));
+      numeric("--min-coverage", options.minCoverage, 0, 100);
+      const exts = options.ext ? splitList(options.ext) : void 0;
+      const stdinContent = paths.includes(STDIN) ? await readStdin() : void 0;
+      const result = await runInferSchema({
+        inputs: paths,
+        exts,
+        exclude: options.exclude,
+        as: options.as,
+        ...configOption(options.config),
+        onConfigLoaded: reportConfig(format === "pretty", process.cwd()),
+        stdinContent,
+        out: options.out,
+        minCoverage: options.minCoverage,
+        // Same shape as the other four input-taking commands: only an
+        // explicit `--allow-empty` / `--no-gitignore` travels, so config
+        // `allowEmpty:` and `respectGitignore:` still decide otherwise.
+        allowEmpty: options.allowEmpty ? true : void 0,
+        respectGitignore: gitignoreFlag(options.gitignore),
+        // Accepted and ignored — `infer` never fetches. `undefined` rather
+        // than `false` all the same, so this stays the same shape as the
+        // other four if it ever does gain a meaning.
+        offline: options.offline ? true : void 0,
+        onNotice: notice
+      });
+      if (format === "json") {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+        return;
+      }
+      const text = renderInfer(result, {
+        color: resolveColor(command.parent?.parent ?? command)
+      });
+      process.stdout.write(`${text}
+`);
+    } catch (err) {
+      fail(err);
+    }
+  });
+  schemas.command("vendor").description(
+    "Download a remote schema into this repository and pin it in config"
+  ).argument("<url>", "http(s) URL of the schema to vendor").option(
+    "--dir <path>",
+    "directory for the committed copy",
+    DEFAULT_VENDOR_DIR
+  ).option("-c, --config <path>", "path to a manni config file").addHelpText(
+    "after",
+    [
+      "",
+      "Examples:",
+      "  manni meta schemas vendor https://schemas.example.com/house/2.1.json",
+      "  manni meta schemas vendor https://schemas.example.com/house/2.1.json --dir ./contracts",
+      "",
+      "Commit both the downloaded file and the config change: the point of",
+      "vendoring is that CI validates against a copy in your own history."
+    ].join("\n")
+  ).action(async (url, options) => {
+    try {
+      const result = await runVendorSchema({
+        url,
+        dir: options.dir,
+        // `typeof === "string"`, not `!== undefined`. `vendor` is the one
+        // config-taking command with no `--no-config`, and the parity rule in
+        // CLAUDE.md points straight at adding one — at which point commander
+        // starts passing `false` here. The annotation on `VendorCliOptions`
+        // says that cannot happen, so it would not be caught at the point the
+        // flag is declared; this test is what keeps a `false` out of a field
+        // that must be a path.
+        ...typeof options.config === "string" ? { configPath: options.config } : {},
+        onNotice: notice
+      });
+      const configNote = result.configCreated ? "created" : result.replaced ? "reference updated" : "reference added";
+      process.stdout.write(
+        [
+          `Vendored ${result.url}`,
+          `  file       ${result.file} (${result.bytes} bytes${result.unchanged ? ", unchanged" : ""})`,
+          `  integrity  ${result.integrity}`,
+          `  config     ${result.config} (${configNote})`,
+          "",
+          `Commit ${result.file} and ${result.config} so CI validates against this copy.`
+        ].join("\n") + "\n"
+      );
+    } catch (err) {
+      fail(err);
+    }
+  });
+  return program;
+}
+
+export {
+  fail,
+  runIfMain,
+  buildProgram
+};
+//# sourceMappingURL=chunk-OXH2ZM7E.js.map