@hawkeyexl/manni 4.3.1 → 4.4.1

package/dist/cli-RPM5PELX.js

@@ -0,0 +1,626 @@
+#!/usr/bin/env node
+import {
+  renderCheck,
+  runCheck
+} from "./chunk-6OYEI2VV.js";
+import {
+  EXPORT_TARGETS,
+  SEARCH_MODES,
+  renderEmbed,
+  renderFill,
+  renderQuery,
+  renderSearch,
+  renderStats,
+  renderTraverse,
+  runEmbed,
+  runExport,
+  runFill,
+  runQuery,
+  runSearch,
+  runStats,
+  runTraverse
+} from "./chunk-RL5XWQOL.js";
+import {
+  DEFAULT_EXTENSIONS,
+  STDIN,
+  assertInputFormat,
+  runBuild
+} from "./chunk-NLXTXE5Y.js";
+import "./chunk-MYMBCTDE.js";
+import {
+  ALL_FILL_FIELDS,
+  CONFIG_SECTION,
+  DEFAULT_CONFIG_FILENAME,
+  GraphError
+} from "./chunk-M2JCK5F6.js";
+import "./chunk-TIUTIOFB.js";
+import "./chunk-TU2WUBVZ.js";
+import "./chunk-QRWGPQKO.js";
+import "./chunk-6JSSEWBG.js";
+import "./chunk-A5ULMVHQ.js";
+import {
+  collect,
+  configOption,
+  readStdin,
+  splitList
+} from "./chunk-TK3FC4RF.js";
+import {
+  writeTextAtomic
+} from "./chunk-M3W7J6MU.js";
+import "./chunk-IDV6HJCB.js";
+import "./chunk-57NEQRVO.js";
+import {
+  fail
+} from "./chunk-YEUYKR62.js";
+import {
+  shouldColor
+} from "./chunk-RNVYGWIC.js";
+import "./chunk-MNH7QO4Z.js";
+import {
+  LOCAL_FLAG_HELP,
+  warn
+} from "./chunk-Q35YIDBV.js";
+import {
+  package_default
+} from "./chunk-UJCVAWP7.js";
+import "./chunk-OWBRDNRZ.js";
+import {
+  errorMessage
+} from "./chunk-G3T47CFV.js";
+import "./chunk-2H7UOFLK.js";
+
+// src/graph/cli.ts
+import { Command } from "commander";
+
+// src/graph/reporters/index.ts
+var GRAPH_FORMATS = ["pretty", "json"];
+var GRAPH_FORMAT_LIST = GRAPH_FORMATS.join(" | ");
+var CHECK_FORMATS = [...GRAPH_FORMATS, "github"];
+var CHECK_FORMAT_LIST = CHECK_FORMATS.join(" | ");
+
+// src/graph/commands/init.ts
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { parse as parseYaml } from "yaml";
+var HEADER = `# manni.config.yaml \u2014 shared configuration for the manni family of tools.
+# Each tool reads its own top-level key; manni graph reads "graph:".
+`;
+var STARTER = `# Base IRI for every minted node. Set this to a namespace you control;
+# without it, IRIs fall back to the urn:manni:graph: placeholder.
+# baseIri: https://example.com/graph/
+
+# There is no document set here. \`manni graph build\` and \`manni graph fill\` read the
+# paths you name, or the collections declared once for every tool at the TOP
+# level of this file, beside \`graph:\` rather than inside it:
+#
+#   collections:
+#     - name: site
+#       paths: ["docs/**/*.md"]
+#
+# Output of \`manni graph build\`.
+out: graph/graph.ttl
+
+# Map published-site routes back to source files so route-style links
+# (/docs/actions/find) become graph edges. A route may also carry the BCP-47
+# \`language\` labelling every document under its root; a page's own \`lang\`
+# frontmatter wins. Uncomment and adjust:
+# routes:
+#   - basePath: /docs
+#     root: docs
+#     extensions: [.md, .mdx, .markdown]
+#     indexFiles: [index, README]
+#   - basePath: /docs/de
+#     root: docs/de
+#     language: de
+
+# What to derive triples from. Remove entries to opt out.
+build:
+  derive: [frontmatter, sections, links, tags, images, code, provenance]
+
+# PROV-O settings. Git history is detected, not switched: per-file dates and
+# author agents, rename -> prov:wasRevisionOf, and the build activity's HEAD
+# committer date are derived wherever git can run over a repository, and a run
+# that cannot says so once and builds the rest. Deterministic per commit;
+# wall-clock time never enters the graph.
+# qualified: emit prov:qualifiedAttribution/qualifiedAssociation nodes
+#   with roles alongside the direct properties.
+provenance:
+  qualified: true
+
+# Which fields a published graph may carry is read from x-manni-graph-output in
+# the schema set \`manni meta validate\` resolves for each page. Set that under
+# meta: (schemas, strict, register), not here. The default set keeps the
+# stewardship people fields (owner, stakeholders, reviewed-by) out.
+
+# SHACL shapes \`manni graph check\` validates the built graph against. Default:
+# the shapes contract bundled with manni (shapes/graph/shapes-1.0.0.ttl).
+# check:
+#   shapes: ["./my-shapes.ttl"]
+
+# Metadata coverage gate for \`manni graph stats --check\`. A number applies to
+# every measured field; a map gates named fields only. Unset gates nothing.
+# stats:
+#   coverageThreshold:
+#     title: 100
+#     description: 50
+
+# Which provider \`manni graph fill\` sends pages to. Unset, the family's
+# top-level providers: map decides, and then \`auto\`, which detects one: an
+# Anthropic key, then an OpenAI key, then the Claude CLI, then a local model.
+# Connection settings (apiKeyEnv, baseUrl, command) live in that map, declared
+# once for every manni tool. \`--provider\` wins over this, \`--local\` over both.
+# provider: anthropic          # auto | anthropic | openai | claude-cli | llama-cpp
+# model: claude-sonnet-4-5     # the provider's default when omitted
+
+# LLM settings for \`manni graph fill\` (SKOS frontmatter proposals).
+fill:
+  temperature: 0
+  # Stop after this many inference calls. One page is one turn, and a cached
+  # page spends none. Unset is unbounded.
+  # maxTurns: 50
+  cacheDir: .manni/graph/cache
+  # fill proposes every field; confidence (0..1 per field) gates what is
+  # written. Fields scored below the threshold are reported, not written.
+  confidenceThreshold: 0.7
+  # fields: defaults to every fillable field \u2014 uncomment to restrict.
+  # Record meta-provenance (model + /graph/ pointers + confidence) on filled docs.
+  writeProvenance: true
+  # Reject proposals that would violate the SHACL shapes contract
+  # (broader/narrower cycles, conflicting labels).
+  validateGraph: true
+  # Also propose per-section metadata. Off by default: it costs more output per
+  # call, and section metadata is explicit-only, so review it as carefully.
+  sections: false
+
+# Local embeddings for semantic search (\`manni graph embed\`). Needs the optional
+# peer: npm install @huggingface/transformers
+# embed:
+#   model: onnx-community/granite-embedding-small-english-r2-ONNX
+#   dtype: q8            # q8 keeps embedding reproducible across platforms
+#   out: graph              # directory for the per-language vector sidecars
+#   cacheDir: .manni/graph/embed-cache
+
+# Optional enrichment for \`manni graph export iirds\` (the iiRDS package).
+# Absent, a minimal valid package is still produced.
+# export:
+#   iirds:
+#     title: My Docs        # package title (default: "manni graph export")
+#     creator: Acme Corp     # Creator iirds:Party + vcard:Organization
+#     version: "1.3"         # iiRDS version literal: "1.2" | "1.3"
+`;
+function starterSection() {
+  const body = STARTER.split("\n").map((line) => line === "" ? "" : `  ${line}`).join("\n");
+  return `${CONFIG_SECTION}:
+${body}`;
+}
+async function runInit(cwd = process.cwd()) {
+  const path = resolve(cwd, DEFAULT_CONFIG_FILENAME);
+  if (!existsSync(path)) {
+    await writeTextAtomic(path, `${HEADER}${starterSection()}`);
+    return path;
+  }
+  const text = readFileSync(path, "utf8");
+  let doc;
+  try {
+    doc = parseYaml(text);
+  } catch (e) {
+    throw new GraphError(
+      `Invalid YAML in ${DEFAULT_CONFIG_FILENAME}: ${errorMessage(e)}`
+    );
+  }
+  if (doc != null && (typeof doc !== "object" || Array.isArray(doc))) {
+    throw new GraphError(
+      `${DEFAULT_CONFIG_FILENAME}: top level must be a mapping \u2014 not adding a \`${CONFIG_SECTION}:\` section to it.`
+    );
+  }
+  if (doc != null && Object.hasOwn(doc, CONFIG_SECTION)) {
+    throw new GraphError(
+      `${DEFAULT_CONFIG_FILENAME} already has a \`${CONFIG_SECTION}:\` section \u2014 not overwriting.`
+    );
+  }
+  const separator = text === "" || text.endsWith("\n") ? "" : "\n";
+  const blank = text === "" ? "" : "\n";
+  await writeTextAtomic(
+    path,
+    `${text}${separator}${blank}${starterSection()}`
+  );
+  return path;
+}
+
+// src/graph/cli.ts
+function colorFor(command, isTTY, env) {
+  const noColor = colorOwner(command).opts().color === false;
+  return shouldColor({ noColor, isTTY, env });
+}
+function colorOwner(command) {
+  for (let c = command; c !== null; c = c.parent) {
+    if (c.options.some((o) => o.long === "--no-color")) return c;
+  }
+  return command;
+}
+function buildProgram() {
+  const program = new Command();
+  program.name("graph").description(
+    "Deterministic knowledge graphs derived from documentation frontmatter and formatting."
+  ).version(package_default.version).option("--no-color", "disable colored output").showHelpAfterError("(add --help for usage)").exitOverride();
+  function numericOption(flag, { min, max, integer }) {
+    return (raw) => {
+      const value = Number.parseFloat(raw);
+      if (!Number.isFinite(value)) {
+        throw new GraphError(`${flag} expects a number, got "${raw}".`);
+      }
+      if (integer && !Number.isInteger(value)) {
+        throw new GraphError(`${flag} expects a whole number, got ${value}.`);
+      }
+      if (value < min || max !== void 0 && value > max) {
+        const range = max === void 0 ? `>= ${min}` : `${min}..${max}`;
+        throw new GraphError(`${flag} must be ${range}, got ${value}.`);
+      }
+      return value;
+    };
+  }
+  function countOption(flag, min = 1) {
+    return numericOption(flag, { min, integer: true });
+  }
+  function enumOption(flag, allowed) {
+    return (raw) => {
+      if (!allowed.includes(raw)) {
+        throw new GraphError(
+          `${flag} must be one of ${allowed.join(" | ")}, got "${raw}".`
+        );
+      }
+      return raw;
+    };
+  }
+  function choiceOption(flag, allowed) {
+    return (raw) => {
+      if (!allowed.includes(raw)) {
+        throw new GraphError(`Unknown ${flag} "${raw}". Use ${allowed.join(" | ")}.`);
+      }
+      return raw;
+    };
+  }
+  const formatOption = choiceOption("--format", GRAPH_FORMATS);
+  const checkFormatOption = choiceOption("--format", CHECK_FORMATS);
+  const fieldsOption = (raw) => splitList(raw).map((value) => enumOption("--fields", ALL_FILL_FIELDS)(value));
+  function documentInputs(command, verb) {
+    return command.argument(
+      "[paths...]",
+      `files, directories, or globs to ${verb} (use - for stdin)`
+    ).option(
+      "--collection <name>",
+      "Configured collection to read (repeatable)",
+      collect,
+      []
+    ).option("--exclude <glob>", "Glob to exclude (repeatable)", collect, []).option("--as <format>", "force an input format (markdown, mdx)").option(
+      "--ext <list>",
+      "comma-separated extensions for directory walks",
+      DEFAULT_EXTENSIONS.join(",")
+    ).option("--allow-empty", "treat zero matched files as success").option("-c, --config <path>", "Path to manni.config.yaml").option("--no-config", "Ignore any discovered config file");
+  }
+  async function inputOptions(paths, opts) {
+    assertInputFormat(paths, opts.as);
+    return {
+      ...opts.as === void 0 ? {} : { as: opts.as },
+      ext: splitList(opts.ext),
+      ...opts.allowEmpty === true ? { allowEmpty: true } : {},
+      ...paths.includes(STDIN) ? { stdinContent: await readStdin() } : {}
+    };
+  }
+  function configInputs(command) {
+    return command.option("-c, --config <path>", "Path to manni.config.yaml").option("--no-config", "Ignore any discovered config file");
+  }
+  function rest(opts) {
+    const { config, ...others } = opts;
+    return others;
+  }
+  function documentOptions(opts) {
+    const { configPath, noConfig } = configOption(opts.config);
+    return {
+      ...configPath === void 0 ? {} : { config: configPath },
+      ...noConfig === true ? { noConfig } : {},
+      ...opts.collection === void 0 ? {} : { collection: opts.collection },
+      ...opts.exclude === void 0 ? {} : { exclude: opts.exclude }
+    };
+  }
+  program.command("init").description("Add a starter `graph:` section to manni.config.yaml in the current directory").action(async () => {
+    try {
+      console.log(`Created ${await runInit()}`);
+    } catch (e) {
+      fail(e);
+    }
+  });
+  documentInputs(
+    program.command("build").description("Derive the knowledge graph and write deterministic Turtle"),
+    "build"
+  ).option("-o, --out <path>", "Output .ttl path (default: config out)").action(async (paths, opts) => {
+    try {
+      const result = await runBuild({
+        paths,
+        ...documentOptions(opts),
+        ...await inputOptions(paths, opts),
+        out: opts.out
+      });
+      for (const warning of result.warnings) warn(warning);
+      console.log(
+        `Wrote ${result.outPath} (${result.docs} docs, ${result.quads} triples)`
+      );
+    } catch (e) {
+      fail(e);
+    }
+  });
+  configInputs(
+    program.command("check").description(
+      "Validate the built graph against the bundled SHACL shapes (errors exit 1)"
+    )
+  ).option("-g, --graph <path>", "Graph .ttl path (default: config out)").option(
+    "--shapes <path>",
+    "Shapes .ttl file; repeatable (default: config check.shapes, then bundled)",
+    collect,
+    []
+  ).option(
+    "-f, --format <format>",
+    `Output: ${CHECK_FORMAT_LIST}`,
+    checkFormatOption,
+    "pretty"
+  ).action(
+    async (opts) => {
+      try {
+        const report = await runCheck({ ...rest(opts), ...documentOptions(opts) });
+        console.log(renderCheck(report, opts.format));
+        process.exitCode = report.exitCode;
+      } catch (e) {
+        fail(e);
+      }
+    }
+  );
+  documentInputs(
+    program.command("fill").description(
+      "Propose `graph:` frontmatter fields with an LLM, gated by confidence, and write them back"
+    ),
+    "fill"
+  ).option(
+    "-f, --format <format>",
+    `Output: ${GRAPH_FORMAT_LIST}`,
+    formatOption,
+    "pretty"
+  ).option("--dry-run", "Report proposals without writing files").option("--force", "Overwrite human-set graph fields").option("--no-cache", "Bypass the proposal cache").option("--no-validate-graph", "Skip the SHACL graph guardrail on proposals").option("--sections", "Also propose per-section metadata").option(
+    "--max-turns <n>",
+    "Stop after this many inference calls (a cached page costs none)",
+    countOption("--max-turns")
+  ).option(
+    "--confidence <n>",
+    "Minimum model confidence (0..1) to write a field (default: config, 0.7)",
+    numericOption("--confidence", { min: 0, max: 1 })
+  ).option(
+    // Comma-separated and given once: one separator per list (proposal 0034).
+    "--fields <list>",
+    `Fields to propose (comma-separated; default: config, then every field)`,
+    fieldsOption
+  ).option(
+    "--provider <name>",
+    "Provider: auto (default) | anthropic | openai | claude-cli | llama-cpp"
+  ).option("--model <model>", "Model override; needs a named provider, from here or config").option("--local", LOCAL_FLAG_HELP).action(async (paths, opts) => {
+    try {
+      const report = await runFill({
+        paths,
+        ...documentOptions(opts),
+        ...await inputOptions(paths, opts),
+        dryRun: opts.dryRun,
+        force: opts.force,
+        noCache: opts.cache === false,
+        noValidateGraph: opts.validateGraph === false,
+        sections: opts.sections,
+        maxTurns: opts.maxTurns,
+        confidence: opts.confidence,
+        fields: opts.fields,
+        provider: opts.provider,
+        model: opts.model,
+        local: opts.local
+      });
+      for (const warning of report.warnings) warn(warning);
+      const rendered = renderFill(report, opts.format);
+      if (paths.includes(STDIN)) {
+        if (report.stdinDocument !== void 0) {
+          process.stdout.write(report.stdinDocument);
+        }
+        if (rendered.length > 0) process.stderr.write(`${rendered}
+`);
+      } else {
+        console.log(rendered);
+      }
+      process.exitCode = report.exitCode;
+    } catch (e) {
+      fail(e);
+    }
+  });
+  program.command("query").description(
+    "Match triple patterns against the built graph (omit a term for wildcard)"
+  ).option("--subject <term>", "Subject IRI or prefixed name").option("--predicate <term>", "Predicate IRI or prefixed name").option("--object <term>", "Object IRI, prefixed name, or literal value").option("-c, --config <path>", "Path to manni.config.yaml").option("--no-config", "Ignore any discovered config file").option("-g, --graph <path>", "Graph .ttl path (default: config out)").option(
+    "-f, --format <format>",
+    `Output: ${GRAPH_FORMAT_LIST}`,
+    formatOption,
+    "pretty"
+  ).action(
+    (opts) => {
+      try {
+        const { subject, predicate, object, ...others } = rest(opts);
+        const result = runQuery({
+          ...others,
+          ...documentOptions(opts),
+          ...subject === void 0 ? {} : { s: subject },
+          ...predicate === void 0 ? {} : { p: predicate },
+          ...object === void 0 ? {} : { o: object }
+        });
+        console.log(renderQuery(result, opts.format));
+      } catch (e) {
+        fail(e);
+      }
+    }
+  );
+  program.command("stats").description(
+    "Summarize the built graph: counts, orphans, broken links, hubs, metadata coverage"
+  ).option("-c, --config <path>", "Path to manni.config.yaml").option("--no-config", "Ignore any discovered config file").option("-g, --graph <path>", "Graph .ttl path (default: config out)").option(
+    "-f, --format <format>",
+    `Output: ${GRAPH_FORMAT_LIST}`,
+    formatOption,
+    "pretty"
+  ).option(
+    "--check",
+    "Exit 1 when broken internal links exist or coverage is below threshold"
+  ).option(
+    "--top <n>",
+    "How many most-connected docs to list",
+    countOption("--top")
+  ).option(
+    "--coverage-threshold <pct>",
+    "Minimum metadata coverage % (all fields); overrides config for this run",
+    // A percentage, so 0..100 rather than the 0..1 of a confidence. NaN here is
+    // worse than a wrong number: `pct < NaN` is false for every field, so the
+    // gate this flag exists to tighten would silently pass instead.
+    numericOption("--coverage-threshold", { min: 0, max: 100 })
+  ).action(
+    (opts) => {
+      try {
+        const report = runStats({ ...rest(opts), ...documentOptions(opts) });
+        console.log(renderStats(report, opts.format));
+        process.exitCode = report.exitCode;
+      } catch (e) {
+        fail(e);
+      }
+    }
+  );
+  program.command("search").description("Rank graph nodes for a text query (needs `export search`)").argument("<query>", "Text query").option("-c, --config <path>", "Path to manni.config.yaml").option("--no-config", "Ignore any discovered config file").option("-g, --graph <path>", "Graph .ttl path (default: config out)").option(
+    "-i, --index <dir>",
+    "Directory holding the indexes and manifest (default: beside the graph)"
+  ).option(
+    "--lang <tag>",
+    "Which localization to search (required when the corpus has more than one)"
+  ).option("--limit <n>", "Maximum results (default 10)", countOption("--limit")).option(
+    "--vectors <path>",
+    "Vector sidecar path (default: from the manifest)"
+  ).option(
+    "--mode <mode>",
+    `Which legs to run: ${SEARCH_MODES.join(" | ")} (default: hybrid when vectors exist)`,
+    choiceOption("--mode", SEARCH_MODES)
+  ).option(
+    "-f, --format <format>",
+    `Output: ${GRAPH_FORMAT_LIST}`,
+    formatOption,
+    "pretty"
+  ).action(
+    async (query, opts) => {
+      try {
+        const report = await runSearch({
+          ...rest(opts),
+          ...documentOptions(opts),
+          query
+        });
+        console.log(renderSearch(report, opts.format));
+      } catch (e) {
+        fail(e);
+      }
+    }
+  );
+  program.command("traverse").description(
+    "Walk the graph from a node, honoring scope rules, with the full trace"
+  ).argument("<node>", "Starting node: a full IRI or a prefix:local CURIE").option("-c, --config <path>", "Path to manni.config.yaml").option("--no-config", "Ignore any discovered config file").option("-g, --graph <path>", "Graph .ttl path (default: config out)").option(
+    "-d, --depth <n>",
+    "Maximum hops from the node (default 1; 3 under --impact)",
+    // Zero is allowed: it means the node itself, which is a real answer.
+    countOption("--depth", 0)
+  ).option(
+    "--predicates <list>",
+    "Only follow these predicates (comma-separated)"
+  ).option("--reverse", "Follow inbound edges (who points at this node)").option("--impact", "Transitive inbound reach: what a change here affects").option(
+    "--variant <variant>",
+    "Scope filter: product variant IRI, title, or slug"
+  ).option("--software-subject <subject>", "Scope filter: software subject").option("--lang <tag>", "Scope filter: BCP-47 language tag, matched in any case").option("--limit <n>", "Stop after this many nodes", countOption("--limit")).option(
+    "-f, --format <format>",
+    `Output: ${GRAPH_FORMAT_LIST}`,
+    formatOption,
+    "pretty"
+  ).action(
+    (node, opts) => {
+      try {
+        const { softwareSubject, ...others } = rest(opts);
+        const report = runTraverse({
+          ...others,
+          ...documentOptions(opts),
+          ...softwareSubject === void 0 ? {} : { subject: softwareSubject },
+          node,
+          predicates: opts.predicates === void 0 ? void 0 : splitList(opts.predicates)
+        });
+        console.log(renderTraverse(report, opts.format));
+      } catch (e) {
+        fail(e);
+      }
+    }
+  );
+  program.command("embed").description(
+    "Compute local embeddings for the search index (needs @huggingface/transformers)"
+  ).option("-c, --config <path>", "Path to manni.config.yaml").option("--no-config", "Ignore any discovered config file").option("-g, --graph <path>", "Graph .ttl path (default: config out)").option(
+    "-i, --index <dir>",
+    "Directory holding the indexes and manifest (default: beside the graph)"
+  ).option(
+    "-o, --out <dir>",
+    "Directory for the sidecars (default: the index directory)"
+  ).option(
+    "--embedding-model <id>",
+    "Embedding model id (any id; `mock` for offline runs)"
+  ).option("--dtype <dtype>", "Weight quantization (default q8)").option("--no-cache", "Ignore the vector cache").option(
+    "-f, --format <format>",
+    `Output: ${GRAPH_FORMAT_LIST}`,
+    formatOption,
+    "pretty"
+  ).action(
+    async (opts) => {
+      try {
+        const { embeddingModel, ...others } = rest(opts);
+        const report = await runEmbed({
+          ...others,
+          ...documentOptions(opts),
+          ...embeddingModel === void 0 ? {} : { model: embeddingModel },
+          noCache: opts.cache === false
+        });
+        console.log(renderEmbed(report, opts.format));
+      } catch (e) {
+        fail(e);
+      }
+    }
+  );
+  program.command("export").description(
+    "Reserialize the built graph into a consumer format (jsonld file, iirds package, or search index)"
+  ).argument("<target>", `What to write: ${EXPORT_TARGETS.join(" | ")}`).option("-c, --config <path>", "Path to manni.config.yaml").option("--no-config", "Ignore any discovered config file").option("-g, --graph <path>", "Graph .ttl path (default: config out)").option(
+    "-o, --out <path>",
+    "Output path (default: the graph path with the target's extension)"
+  ).action(
+    async (target, opts) => {
+      try {
+        if (!EXPORT_TARGETS.includes(target)) {
+          throw new GraphError(
+            `Unknown export target "${target}". Use ${EXPORT_TARGETS.join(" | ")}.`
+          );
+        }
+        const result = await runExport({
+          ...documentOptions(opts),
+          graph: opts.graph,
+          format: target,
+          out: opts.out
+        });
+        for (const warning of result.warnings) warn(warning);
+        console.log(
+          `Wrote ${result.nodes} node${result.nodes === 1 ? "" : "s"} to ${result.outPath}`
+        );
+      } catch (e) {
+        fail(e);
+      }
+    }
+  );
+  return program;
+}
+export {
+  buildProgram,
+  colorFor
+};
+//# sourceMappingURL=cli-RPM5PELX.js.map