@avodado/cli 0.0.1

package/dist/bin.js

@@ -0,0 +1,845 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import pc3 from 'picocolors';
+import { useState } from 'react';
+import { render, Text, useApp, Box } from 'ink';
+import { existsSync, statSync, readFileSync } from 'fs';
+import { resolve, join, dirname, parse, relative, basename, extname, sep } from 'path';
+import { parse as parse$1 } from 'yaml';
+import { createJiti } from 'jiti';
+import { BLOCK_TYPES, parseDocument, validateDocument, resolveRefs, helpUrl } from '@avodado/core';
+import { mkdir, cp, writeFile, readFile } from 'fs/promises';
+import fg from 'fast-glob';
+import { renderDocument } from '@avodado/render';
+import { toHtml, toPdf } from '@avodado/export';
+import { createHash } from 'crypto';
+import { tmpdir } from 'os';
+import open from 'open';
+import { fileURLToPath } from 'url';
+import { parseOpenApi, openapiToMarkdown } from '@avodado/sync';
+import SelectInput from 'ink-select-input';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+var DEFAULTS = { docsDir: "docs", outDir: "dist" };
+var CONFIG_FILES = [
+  "avodado.config.ts",
+  "avodado.config.js",
+  "avodado.config.mjs",
+  "avodado.config.json",
+  "avodado.config.yml",
+  "avodado.config.yaml"
+];
+async function loadConfig(cwd) {
+  for (const name of CONFIG_FILES) {
+    const path = resolve(cwd, name);
+    if (!existsSync(path)) continue;
+    const raw = await readConfig(path);
+    return mergeWithDefaults(raw);
+  }
+  return DEFAULTS;
+}
+async function readConfig(path) {
+  if (path.endsWith(".json")) {
+    return JSON.parse(readFileSync(path, "utf8"));
+  }
+  if (path.endsWith(".yml") || path.endsWith(".yaml")) {
+    return parse$1(readFileSync(path, "utf8"));
+  }
+  const jiti = createJiti(import.meta.url);
+  const mod = await jiti.import(path);
+  return mod.default ?? mod;
+}
+function mergeWithDefaults(raw) {
+  if (raw === null || typeof raw !== "object") return DEFAULTS;
+  const r = raw;
+  return {
+    docsDir: typeof r.docsDir === "string" ? r.docsDir : DEFAULTS.docsDir,
+    outDir: typeof r.outDir === "string" ? r.outDir : DEFAULTS.outDir
+  };
+}
+async function loadDocs(patterns, cwd, docsRoot) {
+  const matches = await fg(patterns, {
+    cwd,
+    absolute: true,
+    onlyFiles: true,
+    dot: false
+  });
+  const docsRootAbs = resolve(cwd, docsRoot);
+  const files = await Promise.all(
+    matches.map(async (absolute) => {
+      const file = relative(cwd, absolute);
+      const slug = deriveSlug(absolute, docsRootAbs);
+      const source = await readFile(absolute, "utf8");
+      return { absolute, file, slug, source };
+    })
+  );
+  files.sort((a, b) => a.file.localeCompare(b.file));
+  return files;
+}
+function deriveSlug(absolute, docsRootAbs) {
+  const rel = relative(docsRootAbs, absolute);
+  const inside = !rel.startsWith("..") && !rel.startsWith(sep) && rel.length > 0;
+  const path = inside ? rel : basename(absolute);
+  return path.replace(/\\/g, "/").replace(/\.md$/i, "");
+}
+
+// src/commands/check.tsx
+async function runCheck(opts) {
+  const docs = await loadDocs(opts.patterns, opts.cwd, opts.docsRoot);
+  const parsed = docs.map((d) => ({
+    doc: parseDocument(d.source, d.slug),
+    file: d.file
+  }));
+  const diagnostics = [];
+  for (const { doc, file } of parsed) {
+    diagnostics.push(...validateDocument(doc, file));
+  }
+  const resolved = resolveRefs(parsed);
+  diagnostics.push(...resolved.diagnostics);
+  diagnostics.sort((a, b) => {
+    const f = a.file.localeCompare(b.file);
+    if (f !== 0) return f;
+    return (a.line ?? 0) - (b.line ?? 0);
+  });
+  const exitCode = diagnostics.some((d) => d.level === "error") ? 1 : 0;
+  const sources = /* @__PURE__ */ new Map();
+  for (const d of docs) sources.set(d.file, d.source.split(/\r\n|\r|\n/));
+  return {
+    diagnostics,
+    files: docs.map((d) => d.file),
+    sources,
+    exitCode
+  };
+}
+var BASE_THEMES = /* @__PURE__ */ new Set(["navy", "teal", "plum", "slate", "dark", "soft"]);
+var COLOR_TO_VAR = {
+  primary: "--navy",
+  // headings, primary nodes, links, section numbers
+  secondary: "--blue",
+  // secondary accents, CDN/consumer nodes
+  accent: "--highlight",
+  // highlight pills, FK keys, "current" markers
+  positive: "--positive",
+  // success / service nodes / done
+  negative: "--negative",
+  // errors / forbidden edges / danger
+  purple: "--purple",
+  // data / context / provider nodes
+  teal: "--teal",
+  // queues / topics / caches
+  ink: "--charcoal",
+  // body text
+  muted: "--gray",
+  // captions, dim text, external nodes
+  rule: "--rule",
+  // hairlines, borders, dividers
+  paper: "--white"
+  // surfaces / card fills
+};
+var FONT_TO_VAR = {
+  display: "--font-display",
+  // titles / headings
+  body: "--font-body",
+  // paragraphs / labels
+  mono: "--font-mono"
+  // code / technical labels
+};
+var THEME_FILES = ["avodado.theme.json", "avodado.theme.jsonc"];
+function loadTheme(cwd) {
+  for (const name of THEME_FILES) {
+    const path = resolve(cwd, name);
+    if (!existsSync(path)) continue;
+    let raw;
+    try {
+      raw = JSON.parse(stripComments(readFileSync(path, "utf8")));
+    } catch {
+      return {};
+    }
+    const file = raw !== null && typeof raw === "object" ? raw : {};
+    const out = {};
+    if (typeof file.theme === "string" && BASE_THEMES.has(file.theme)) out.theme = file.theme;
+    const vars = toVars(raw);
+    if (vars !== void 0) out.themeVars = vars;
+    return out;
+  }
+  return {};
+}
+function toVars(raw) {
+  if (raw === null || typeof raw !== "object") return void 0;
+  const file = raw;
+  const vars = {};
+  if (file.colors !== void 0) {
+    for (const key of Object.keys(file.colors)) {
+      const cssVar = COLOR_TO_VAR[key.toLowerCase()];
+      const value = file.colors[key];
+      if (cssVar !== void 0 && typeof value === "string") vars[cssVar] = value;
+    }
+  }
+  if (file.fonts !== void 0) {
+    for (const key of Object.keys(file.fonts)) {
+      const cssVar = FONT_TO_VAR[key.toLowerCase()];
+      const value = file.fonts[key];
+      if (cssVar !== void 0 && typeof value === "string") vars[cssVar] = value;
+    }
+  }
+  return Object.keys(vars).length > 0 ? vars : void 0;
+}
+function stripComments(src) {
+  return src.replace(/^\s*\/\/.*$/gm, "");
+}
+
+// src/commands/render.ts
+async function runRender(opts) {
+  const inputAbs = resolve(opts.cwd, opts.input);
+  const source = await readFile(inputAbs, "utf8");
+  const slug = parse(inputAbs).name;
+  const doc = parseDocument(source, slug);
+  const { theme, themeVars } = loadTheme(opts.cwd);
+  const html = renderDocument(doc, {
+    ...theme !== void 0 ? { theme } : {},
+    ...themeVars !== void 0 ? { themeVars } : {}
+  });
+  const outputAbs = opts.output !== void 0 ? resolve(opts.cwd, opts.output) : inputAbs.replace(/\.md$/i, ".html");
+  await mkdir(dirname(outputAbs), { recursive: true });
+  await writeFile(outputAbs, html, "utf8");
+  return { input: opts.input, output: outputAbs, bytes: html.length };
+}
+async function runExport(opts) {
+  const docs = await loadDocs(opts.patterns, opts.cwd, opts.docsRoot);
+  const outRoot = resolve(opts.cwd, opts.outDir);
+  await mkdir(outRoot, { recursive: true });
+  const items = [];
+  for (const d of docs) {
+    const doc = parseDocument(d.source, d.slug);
+    const outputs = [];
+    for (const fmt of opts.formats) {
+      const outPath = join(outRoot, `${d.slug}.${fmt}`);
+      await mkdir(resolve(outPath, ".."), { recursive: true });
+      if (fmt === "html") {
+        const html = toHtml(doc);
+        await writeFile(outPath, html, "utf8");
+        outputs.push({ format: fmt, path: outPath, bytes: html.length });
+      } else {
+        const pdf = await toPdf(doc);
+        await writeFile(outPath, pdf);
+        outputs.push({ format: fmt, path: outPath, bytes: pdf.byteLength });
+      }
+    }
+    items.push({ file: d.file, outputs });
+  }
+  return { items };
+}
+async function runPreview(opts) {
+  const inputAbs = resolve(opts.cwd, opts.input);
+  const source = await readFile(inputAbs, "utf8");
+  const slug = parse(inputAbs).name;
+  const doc = parseDocument(source, slug);
+  const html = renderDocument(doc);
+  const hash = createHash("sha1").update(inputAbs).digest("hex").slice(0, 8);
+  const dir = join(tmpdir(), "avodado-preview");
+  await mkdir(dir, { recursive: true });
+  const out = join(dir, `${slug}-${hash}.html`);
+  await writeFile(out, html, "utf8");
+  await open(out);
+  return { file: out };
+}
+function templatesDir() {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 6; i++) {
+    const candidate = join(dir, "templates");
+    if (existsSync(candidate) && statSync(candidate).isDirectory()) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error(`Could not locate avodado/cli templates directory near ${import.meta.url}`);
+}
+var FILES = [
+  "avodado.config.json",
+  "docs/getting-started.md",
+  "CLAUDE.md",
+  ".cursor/rules/avodado.mdc",
+  ".avodado/skill/SKILL.md"
+];
+async function runInit(opts) {
+  const srcRoot = templatesDir();
+  const created = [];
+  const skipped = [];
+  for (const rel of FILES) {
+    const src = resolve(srcRoot, rel);
+    const dst = join(opts.cwd, rel);
+    if (existsSync(dst) && opts.force !== true) {
+      skipped.push(rel);
+      continue;
+    }
+    await mkdir(dirname(dst), { recursive: true });
+    await cp(src, dst);
+    created.push(rel);
+  }
+  return { created, skipped };
+}
+function slugFromPath(path) {
+  const base = basename(path, extname(path));
+  return base.length > 0 ? base : "api";
+}
+async function runSyncOpenApi(opts) {
+  if (opts.out === void 0 && opts.check === void 0) {
+    return { exitCode: 2, message: "avo sync openapi: must specify --out <path> or --check <path>" };
+  }
+  if (opts.out !== void 0 && opts.check !== void 0) {
+    return { exitCode: 2, message: "avo sync openapi: --out and --check are mutually exclusive" };
+  }
+  const specAbs = resolve(opts.cwd, opts.spec);
+  if (!existsSync(specAbs)) {
+    return { exitCode: 2, message: `Spec not found: ${specAbs}` };
+  }
+  const source = await readFile(specAbs, "utf8");
+  let spec;
+  try {
+    spec = parseOpenApi(source);
+  } catch (err) {
+    return { exitCode: 1, message: `Failed to parse spec: ${err.message}` };
+  }
+  const targetPath = opts.out ?? opts.check;
+  if (targetPath === void 0) {
+    return { exitCode: 2, message: "no target path" };
+  }
+  const slug = opts.slug ?? slugFromPath(targetPath);
+  const generated = openapiToMarkdown(spec, { slug });
+  if (opts.out !== void 0) {
+    const outAbs = resolve(opts.cwd, opts.out);
+    await mkdir(dirname(outAbs), { recursive: true });
+    await writeFile(outAbs, generated, "utf8");
+    return {
+      exitCode: 0,
+      message: `Wrote ${outAbs} (${generated.length} bytes)`
+    };
+  }
+  const checkAbs = resolve(opts.cwd, opts.check ?? "");
+  if (!existsSync(checkAbs)) {
+    return {
+      exitCode: 1,
+      message: `Drift: ${checkAbs} does not exist. Run with --out ${opts.check} to generate it.`
+    };
+  }
+  const existing = await readFile(checkAbs, "utf8");
+  if (existing === generated) {
+    return {
+      exitCode: 0,
+      message: `OK: ${checkAbs} matches ${specAbs} (${generated.length} bytes)`
+    };
+  }
+  return {
+    exitCode: 1,
+    message: `Drift: ${checkAbs} differs from what ${specAbs} would generate.`,
+    diff: simpleDiff(existing, generated)
+  };
+}
+function simpleDiff(a, b) {
+  const aLines = a.split("\n");
+  const bLines = b.split("\n");
+  const out = [];
+  const max = Math.max(aLines.length, bLines.length);
+  for (let i = 0; i < max; i++) {
+    const av = aLines[i];
+    const bv = bLines[i];
+    if (av === bv) continue;
+    if (av !== void 0) out.push(`- ${av}`);
+    if (bv !== void 0) out.push(`+ ${bv}`);
+    if (out.length >= 40) {
+      out.push(`\u2026 (truncated; ${max - i - 1} more lines)`);
+      break;
+    }
+  }
+  return out.join("\n");
+}
+var TEMPLATES = {
+  meta: "```meta\ntitle: New document\nsubtitle: One-line description.\ntag: DRAFT\n```\n",
+  callout: "```callout\ntone: note\ntitle: Heads up\nbody: A short note that the reader should not miss.\n```\n",
+  table: "```table\ncolumns: [Field, Description]\nrows:\n  - [name, Display name]\n  - [id, Stable identifier]\n```\n",
+  sequence: "```sequence\nid: seq-example\nactors:\n  - { id: Client, name: Client }\n  - { id: Server, name: Server }\nmessages:\n  - { from: Client, to: Server, label: request, kind: sync }\n  - { from: Server, to: Client, label: response, kind: response }\n```\n",
+  erd: "```erd\nid: erd-example\nentities:\n  - name: orders\n    columns:\n      - { name: id, type: uuid, pk: true }\n      - { name: user_id, type: uuid, fk: true }\nrelations: []\n```\n",
+  userstory: "```userstory\nid: US-001\nrole: user\nwant: do the thing\nsoThat: I get the outcome\ncriteria:\n  - { given: a precondition, when: I act, then: the outcome }\n```\n",
+  timeline: "```timeline\nitems:\n  - label: Phase 1\n    date: now\n    status: current\n    desc: What is happening now\n  - label: Phase 2\n    date: next\n    status: next\n    desc: What is next\n```\n",
+  kanban: "```kanban\ncolumns:\n  - label: Now\n    cards:\n      - { title: Current task }\n  - label: Next\n    cards:\n      - { title: Upcoming task }\n  - label: Later\n    cards:\n      - { title: Eventually }\n```\n",
+  tracker: "```tracker\nitems:\n  - { task: First task, status: doing, priority: high }\n  - { task: Second task, status: todo, priority: med }\n```\n",
+  prose: "```prose\ntitle: Overview\nblocks:\n  - { type: h, text: Background }\n  - { type: p, text: A paragraph explaining the context. }\n  - { type: ul, items: [Idea one, Idea two, Idea three] }\n```\n",
+  glossary: "```glossary\nterms:\n  - { term: Idempotency, def: Doing a thing twice has the same effect as doing it once. }\n  - { term: SLO, def: Service-level objective the team commits to. }\n```\n",
+  proscons: "```proscons\ntitle: Synchronous vs async\nprosLabel: Synchronous\nconsLabel: Asynchronous\npros:\n  - Easy to reason about\n  - One transaction\ncons:\n  - Latency-bound\n  - Single point of failure\n```\n",
+  cvt: "```cvt\ntitle: Migration plan\ncurrent:\n  label: Today\n  items: [Single monolith, Shared database, Manual deploys]\ntarget:\n  label: Target\n  items: [Modular services, Per-service stores, Automated deploys]\nnote: Migrate one service per quarter.\n```\n",
+  stats: '```stats\ntitle: This quarter\nstats:\n  - { value: 12.4k, label: Active users, delta: "+18%", trend: up }\n  - { value: 99.95%, label: Uptime, delta: "0", trend: flat }\n  - { value: 142ms, label: p95 latency, delta: "-22ms", trend: up }\n```\n',
+  code: "```code\ntitle: Reference\nblocks:\n  - title: index.ts\n    lang: TypeScript\n    code: |\n      export function add(a: number, b: number): number {\n        return a + b;\n      }\n```\n",
+  agenda: '```agenda\nitems:\n  - { time: "09:00", duration: 30m, title: Intros, owner: Host }\n  - { time: "09:30", duration: 45m, title: Status updates, desc: Each team for 5 min }\n  - { time: "10:15", duration: 15m, title: Wrap-up }\n```\n',
+  tree: "```tree\nnodes:\n  - { id: src, label: src }\n  - { id: components, parent: src, label: components }\n  - { id: hooks, parent: src, label: hooks }\n  - { id: index, parent: src, label: index.ts, note: entry point }\n```\n",
+  pyramid: "```pyramid\nlevels:\n  - { label: Vision, desc: Long-term direction }\n  - { label: Strategy, desc: How we get there }\n  - { label: Tactics, desc: This quarter }\n  - { label: Tasks, desc: This week }\n```\n",
+  funnel: "```funnel\nstages:\n  - { label: Visited, value: 10000 }\n  - { label: Signed up, value: 2400 }\n  - { label: Activated, value: 1100 }\n  - { label: Paying, value: 320 }\n```\n",
+  flow: '```flow\ntitle: Decision flow\nnodes:\n  - { id: start, col: 1, row: 1, kind: start, label: Start }\n  - { id: check, col: 2, row: 1, kind: decision, label: Is valid? }\n  - { id: yes, col: 3, row: 1, kind: process, label: Process }\n  - { id: no, col: 2, row: 2, kind: end, label: Reject }\n  - { id: done, col: 3, row: 2, kind: end, label: Done }\nedges:\n  - { from: start, to: check }\n  - { from: check, to: yes, label: "yes" }\n  - { from: check, to: no, label: "no", kind: error }\n  - { from: yes, to: done }\n```\n',
+  state: "```state\ntitle: Order lifecycle\nstates:\n  - { id: s0, col: 1, row: 1, kind: start }\n  - { id: pending, col: 2, row: 1, kind: wait, name: PENDING }\n  - { id: confirmed, col: 3, row: 1, kind: active, name: CONFIRMED }\n  - { id: end, col: 4, row: 1, kind: terminal }\ntransitions:\n  - { from: s0, to: pending, event: create }\n  - { from: pending, to: confirmed, event: pay }\n  - { from: confirmed, to: end, event: ship }\n```\n",
+  dfd: "```dfd\ntitle: Data flow\nnodes:\n  - { id: ext, col: 1, row: 1, kind: external, name: Client }\n  - { id: proc, col: 2, row: 1, kind: process, name: Process, num: 1 }\n  - { id: store, col: 3, row: 1, kind: store, name: Orders }\nedges:\n  - { from: ext, to: proc, label: request }\n  - { from: proc, to: store, label: write }\n```\n",
+  journey: "```journey\ntitle: Onboarding journey\nstages:\n  - { label: Discover }\n  - { label: Sign up }\n  - { label: Activate }\n  - { label: Pay }\nrows:\n  - { label: Touchpoint, cells: [Landing, Form, Email, Checkout] }\n  - { label: Friction, cells: [Low, Med, Low, Med] }\nemotion: [0.7, 0.4, 0.6, 0.8]\n```\n",
+  gantt: "```gantt\ntitle: Roadmap\nperiods: [Q1, Q2, Q3, Q4]\ntasks:\n  - { label: Discovery, start: 0, span: 1, kind: done }\n  - { label: Build, start: 1, span: 2, kind: active }\n  - { label: Ship, start: 3, span: 1 }\n  - { label: GA, start: 3, span: 1, kind: milestone }\n```\n",
+  graph: "```graph\ntitle: Dependency graph\nnodes:\n  - { id: a, col: 1, row: 1, label: Module A, group: 0 }\n  - { id: b, col: 2, row: 1, label: Module B, group: 1 }\n  - { id: c, col: 3, row: 1, label: Module C, group: 2 }\n  - { id: d, col: 2, row: 2, label: Shared, group: 3 }\nedges:\n  - { from: a, to: b }\n  - { from: b, to: c }\n  - { from: a, to: d }\n  - { from: b, to: d, dir: undirected }\n```\n",
+  quadrant: "```quadrant\ntitle: Effort vs impact\nxAxis: { label: Effort, low: Low, high: High }\nyAxis: { label: Impact, low: Low, high: High }\nitems:\n  - { x: 0.2, y: 0.8, label: Quick win }\n  - { x: 0.8, y: 0.8, label: Big bet }\n  - { x: 0.2, y: 0.2, label: Fill-in }\n  - { x: 0.8, y: 0.2, label: Thankless }\n```\n",
+  swimlane: "```swimlane\ntitle: Cross-functional flow\nlanes:\n  - { label: Customer }\n  - { label: Sales }\n  - { label: Ops }\nsteps:\n  - { id: req, col: 1, lane: 0, kind: start, label: Submit request }\n  - { id: qual, col: 2, lane: 1, kind: decision, label: Qualify }\n  - { id: fulfill, col: 3, lane: 2, label: Fulfill }\n  - { id: done, col: 4, lane: 0, kind: end, label: Receive }\nlinks:\n  - { from: req, to: qual }\n  - { from: qual, to: fulfill }\n  - { from: fulfill, to: done }\n```\n",
+  c4: "```c4\ntitle: System context\nlevel: context\nnodes:\n  - { id: user, col: 1, row: 1, kind: person, name: Shopper, desc: A customer placing an order. }\n  - { id: app, col: 2, row: 1, kind: system, name: ShopCo, desc: The retail platform. }\n  - { id: pay, col: 3, row: 1, kind: external, name: Payment GW, desc: Stripe authorisation. }\nedges:\n  - { from: user, to: app, label: places order }\n  - { from: app, to: pay, label: authorises }\n```\n",
+  uml: '```uml\ntitle: Class model\nclasses:\n  - { id: order, col: 1, row: 1, name: Order, attrs: ["id: UUID", "status: Status", "total: Money"], methods: ["place()", "cancel()"] }\n  - { id: item, col: 2, row: 1, name: OrderItem, attrs: ["id: UUID", "sku: String", "qty: int"] }\n  - { id: status, col: 1, row: 2, name: Status, stereotype: enumeration, attrs: ["PENDING", "CONFIRMED", "CANCELLED"] }\nrels:\n  - { from: order, to: item, kind: composition }\n  - { from: order, to: status, kind: association, label: has }\n```\n',
+  mece: "```mece\ntitle: Why are conversions down?\nnodes:\n  - { id: root, label: Lower conversion }\n  - { id: traffic, parent: root, label: Traffic }\n  - { id: friction, parent: root, label: Friction }\n  - { id: t1, parent: traffic, label: Lower quality, note: paid ads }\n  - { id: t2, parent: traffic, label: Wrong audience }\n  - { id: f1, parent: friction, label: Slow checkout }\n  - { id: f2, parent: friction, label: Mobile bugs }\n```\n",
+  frontend: "```frontend\ntitle: React component tree\nnodes:\n  - { id: app, kind: root, name: App }\n  - { id: layout, parent: app, kind: layout, name: Layout }\n  - { id: home, parent: layout, kind: page, name: Home }\n  - { id: orders, parent: layout, kind: page, name: Orders }\n  - { id: card, parent: orders, kind: component, name: OrderCard }\n  - { id: useOrder, parent: orders, kind: hook, name: useOrder }\n  - { id: store, parent: app, kind: store, name: cart, note: Zustand }\n```\n",
+  cluster: "```cluster\ntitle: Production cluster\nclusters:\n  - { id: api, label: api namespace, kind: namespace }\n  - { id: data, label: data namespace, kind: namespace }\nservices:\n  - { id: web, cluster: api, label: web, kind: service, tech: Next.js, replicas: 3 }\n  - { id: orders, cluster: api, label: orders, kind: service, tech: Go, replicas: 4 }\n  - { id: pg, cluster: data, label: postgres, kind: store, tech: Postgres 16, replicas: 1 }\n  - { id: redis, cluster: data, label: redis, kind: cache, tech: Redis 7, replicas: 2 }\nedges:\n  - { from: web, to: orders }\n  - { from: orders, to: pg }\n  - { from: orders, to: redis }\n```\n",
+  block: '```block\ntitle: System architecture\ngroups:\n  - { col: 1, row: 1, cols: 1, rows: 2, label: Edge, color: "#0e54a1" }\n  - { col: 2, row: 1, cols: 2, rows: 2, label: Services, color: "#1f9747" }\nnodes:\n  - { id: cdn, col: 1, row: 1, kind: cdn, name: CDN, tech: Cloudflare }\n  - { id: gw, col: 1, row: 2, kind: gateway, name: Gateway, tech: Envoy }\n  - { id: api, col: 2, row: 1, kind: service, name: API, tech: Go }\n  - { id: worker, col: 3, row: 1, kind: service, name: Worker, tech: Go }\n  - { id: pg, col: 2, row: 2, kind: store, name: Postgres, tech: "16" }\n  - { id: q, col: 3, row: 2, kind: queue, name: Events, tech: NATS }\nedges:\n  - { from: cdn, to: gw }\n  - { from: gw, to: api }\n  - { from: api, to: pg }\n  - { from: api, to: q }\n  - { from: q, to: worker, kind: dashed }\n```\n',
+  infra: "```infra\ntitle: AWS topology\nsystemLabel: ShopCo \xB7 us-east-1\nlayers:\n  - { label: Edge }\n  - { label: Compute }\n  - { label: Data }\nnodes:\n  - { id: cf, layer: 0, kind: cdn, name: CloudFront, tech: CDN }\n  - { id: alb, layer: 0, kind: gateway, name: ALB, tech: Application LB }\n  - { id: api, layer: 1, kind: service, name: API, tech: ECS Fargate }\n  - { id: worker, layer: 1, kind: service, name: Worker, tech: ECS Fargate }\n  - { id: pg, layer: 2, kind: store, name: orders-db, tech: RDS Postgres }\n  - { id: cache, layer: 2, kind: cache, name: cache, tech: ElastiCache }\nedges:\n  - { from: cf, to: alb }\n  - { from: alb, to: api }\n  - { from: api, to: pg }\n  - { from: api, to: cache }\n  - { from: api, to: worker, kind: dashed }\n```\n",
+  event: "```event\ntitle: Pub/sub choreography\nnodes:\n  - { id: orders, col: 1, row: 1, kind: producer, name: orders }\n  - { id: bus, col: 2, row: 1, kind: topic, name: order.events }\n  - { id: ship, col: 3, row: 1, kind: consumer, name: shipping }\n  - { id: bill, col: 3, row: 2, kind: consumer, name: billing }\nedges:\n  - { from: orders, to: bus }\n  - { from: bus, to: ship }\n  - { from: bus, to: bill }\n```\n",
+  ddd: "```ddd\ntitle: Bounded contexts\nnodes:\n  - { id: cat, col: 1, row: 1, kind: context, name: Catalog }\n  - { id: order, col: 2, row: 1, kind: context, name: Orders }\n  - { id: pay, col: 3, row: 1, kind: context, name: Payments }\n  - { id: ship, col: 2, row: 2, kind: context, name: Shipping }\nedges:\n  - { from: order, to: cat, label: reads, kind: dashed }\n  - { from: order, to: pay }\n  - { from: order, to: ship }\n```\n",
+  network: "```network\ntitle: Security zones\nnodes:\n  - { id: edge, col: 1, row: 1, kind: gateway, name: Edge / WAF }\n  - { id: fw, col: 2, row: 1, kind: firewall, name: Perimeter FW }\n  - { id: api, col: 3, row: 1, kind: service, name: API }\n  - { id: db, col: 3, row: 2, kind: store, name: DB (private) }\nedges:\n  - { from: edge, to: fw }\n  - { from: fw, to: api }\n  - { from: api, to: db }\n```\n",
+  felogic: "```felogic\ntitle: Frontend modules\nnodes:\n  - { id: hook, col: 1, row: 1, kind: hook, name: useOrders }\n  - { id: svc, col: 2, row: 1, kind: service, name: ordersService }\n  - { id: iface, col: 3, row: 1, kind: interface, name: OrdersClient }\n  - { id: impl, col: 4, row: 1, kind: strategy, name: HttpOrdersClient }\n  - { id: api, col: 5, row: 1, kind: external, name: Orders API }\nedges:\n  - { from: hook, to: svc }\n  - { from: svc, to: iface, kind: uses }\n  - { from: impl, to: iface, kind: implements }\n  - { from: impl, to: api, kind: egress, label: HTTPS }\n```\n",
+  belogic: "```belogic\ntitle: Backend modules\nnodes:\n  - { id: ctrl, col: 1, row: 1, kind: controller, name: OrdersController }\n  - { id: svc, col: 2, row: 1, kind: service, name: PlaceOrder }\n  - { id: repo, col: 3, row: 1, kind: repository, name: OrdersRepo }\n  - { id: db, col: 4, row: 1, kind: db, name: postgres }\n  - { id: pay, col: 3, row: 2, kind: external, name: Stripe }\nedges:\n  - { from: ctrl, to: svc }\n  - { from: svc, to: repo }\n  - { from: repo, to: db, kind: reads }\n  - { from: svc, to: pay, kind: egress, label: authorise }\n```\n",
+  dag: "```dag\ntitle: Build pipeline\nnodes:\n  - { id: src, col: 1, row: 1, kind: start, label: Source }\n  - { id: lint, col: 2, row: 1, kind: process, label: Lint }\n  - { id: test, col: 3, row: 1, kind: process, label: Test }\n  - { id: build, col: 4, row: 1, kind: process, label: Build }\n  - { id: deploy, col: 5, row: 1, kind: end, label: Deploy }\nedges:\n  - { from: src, to: lint }\n  - { from: lint, to: test }\n  - { from: test, to: build }\n  - { from: build, to: deploy }\n```\n",
+  wireframe: '```wireframe\ntitle: What the user sees\nscreens:\n  - device: browser\n    title: Dashboard\n    url: app.example.com\n    label: Desktop\n    elements:\n      - { type: nav, label: "Home, Inbox, Settings" }\n      - { type: header, label: Notifications }\n      - { type: list, rows: 4 }\n      - { type: button, label: Mark all as read }\n  - device: phone\n    title: "9:41"\n    label: iPhone\n    elements:\n      - { type: header, label: Alerts }\n      - { type: card, rows: 3 }\n      - { type: tabs, label: "Home, Search, Bell, You" }\n```\n'
+};
+function templateFor(type) {
+  return `\`\`\`meta
+title: New document
+tag: DRAFT
+\`\`\`
+
+## ${type}
+
+${TEMPLATES[type]}`;
+}
+var ADR_TEMPLATE = [
+  "```meta",
+  "title: ADR-NNN \u2014 decision title",
+  "subtitle: One line on what we decided and why it matters.",
+  "tag: ADR \xB7 Proposed \xB7 YYYY-MM-DD",
+  "```",
+  "",
+  "## Status",
+  "",
+  "**Proposed** \u2014 YYYY-MM-DD. (Proposed \u2192 Accepted \u2192 Superseded.)",
+  "",
+  "## Context",
+  "",
+  "What forces a decision here? The constraints, requirements, and the problem",
+  "being solved. Two to four sentences of plain prose \u2014 no block needed.",
+  "",
+  "```callout",
+  "tone: note",
+  "title: Decision",
+  'body: "State the decision in one or two sentences \u2014 what we will do, and the single most important reason why."',
+  "```",
+  "",
+  "## Options considered",
+  "",
+  "```proscons",
+  "id: the-choice",
+  "title: Chosen option vs the alternative",
+  "prosLabel: Chosen option",
+  "consLabel: The alternative",
+  "pros:",
+  "  - A concrete reason the chosen option wins",
+  "  - Another benefit worth the trade-off",
+  "cons:",
+  "  - A real cost of the alternative",
+  "  - Another drawback we are accepting against",
+  "```",
+  "",
+  "## Architecture",
+  "",
+  "```block",
+  "id: architecture",
+  "title: How it fits together",
+  "nodes:",
+  "  - { id: client, col: 1, row: 1, kind: client, name: Client }",
+  "  - { id: svc, col: 2, row: 1, kind: service, name: Service, tech: your stack }",
+  "  - { id: db, col: 3, row: 1, kind: store, name: Database }",
+  "edges:",
+  "  - { from: client, to: svc }",
+  "  - { from: svc, to: db }",
+  "```",
+  "",
+  "## Consequences",
+  "",
+  "```tracker",
+  "id: consequences",
+  "title: Consequences & follow-ups",
+  "items:",
+  '  - { task: "Something that becomes easier or newly required", status: todo, priority: high }',
+  '  - { task: "A migration or new responsibility this creates", status: todo, priority: med }',
+  '  - { task: "A risk to watch as we roll this out", status: todo, priority: low }',
+  "```",
+  ""
+].join("\n");
+var DOC_TEMPLATES = {
+  adr: ADR_TEMPLATE
+};
+function isDocTemplate(name) {
+  return Object.prototype.hasOwnProperty.call(DOC_TEMPLATES, name);
+}
+async function writeNewDoc(opts) {
+  const outAbs = resolve(opts.cwd, opts.out);
+  await mkdir(dirname(outAbs), { recursive: true });
+  const content = isDocTemplate(opts.type) ? DOC_TEMPLATES[opts.type] : templateFor(opts.type);
+  await writeFile(outAbs, content, "utf8");
+  return outAbs;
+}
+function NewPicker({ onPick }) {
+  const items = BLOCK_TYPES.map((t) => ({ label: t, value: t }));
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, children: "Pick a block type to scaffold:" }),
+    /* @__PURE__ */ jsx(
+      SelectInput,
+      {
+        items,
+        onSelect: (item) => onPick(item.value)
+      }
+    )
+  ] });
+}
+function NewApp({ cwd, out }) {
+  const [picked, setPicked] = useState(null);
+  const [writtenPath, setWrittenPath] = useState(null);
+  const { exit } = useApp();
+  const handlePick = (type) => {
+    setPicked(type);
+    void writeNewDoc({ cwd, type, out }).then((path) => {
+      setWrittenPath(path);
+      setTimeout(exit, 50);
+    });
+  };
+  if (writtenPath !== null) {
+    return /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { color: "green", children: "\u2713" }),
+      /* @__PURE__ */ jsx(Text, { children: " Wrote " }),
+      /* @__PURE__ */ jsx(Text, { bold: true, children: writtenPath })
+    ] });
+  }
+  if (picked !== null) {
+    return /* @__PURE__ */ jsxs(Text, { children: [
+      "Writing ",
+      out,
+      "\u2026"
+    ] });
+  }
+  return /* @__PURE__ */ jsx(NewPicker, { onPick: handlePick });
+}
+function renderCodeFrame(input) {
+  const { lines, line } = input;
+  if (line < 1 || line > lines.length) return "";
+  const contextBefore = input.contextBefore ?? 1;
+  const start = Math.max(1, line - contextBefore);
+  const gutterWidth = String(line).length + 1;
+  const tint = input.level === "warn" ? pc3.yellow : pc3.red;
+  const out = [];
+  for (let n = start; n <= line; n++) {
+    const text = lines[n - 1] ?? "";
+    const gutter = pc3.dim(`${String(n).padStart(gutterWidth)} | `);
+    out.push(gutter + text);
+  }
+  if (input.column !== void 0 && input.column >= 1) {
+    const col = input.column;
+    const span = input.endColumn !== void 0 ? Math.max(1, input.endColumn - col) : 1;
+    const pad = " ".repeat(gutterWidth) + pc3.dim(" | ") + " ".repeat(col - 1);
+    out.push(pad + tint("^".repeat(span)));
+  }
+  return out.join("\n");
+}
+var COLOR = {
+  error: "red",
+  warn: "yellow"
+};
+function frameFor(d, sources) {
+  if (d.line === void 0) return "";
+  const lines = sources.get(d.file);
+  if (lines === void 0) return "";
+  return renderCodeFrame({
+    lines,
+    line: d.line,
+    ...d.column !== void 0 ? { column: d.column } : {},
+    ...d.endColumn !== void 0 ? { endColumn: d.endColumn } : {},
+    level: d.level
+  });
+}
+function DiagnosticsTable({ diagnostics, fileCount, sources }) {
+  const errorCount = diagnostics.filter((d) => d.level === "error").length;
+  const warnCount = diagnostics.filter((d) => d.level === "warn").length;
+  if (diagnostics.length === 0) {
+    return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: /* @__PURE__ */ jsxs(Text, { color: "green", children: [
+      "\u2713 ",
+      fileCount,
+      " ",
+      fileCount === 1 ? "file" : "files",
+      " checked \u2014 no diagnostics"
+    ] }) });
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    diagnostics.map((d, i) => {
+      const frame = frameFor(d, sources);
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+        /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsxs(Text, { color: COLOR[d.level], bold: true, children: [
+            d.level === "error" ? "\u2716" : "\u26A0",
+            " "
+          ] }),
+          /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+            d.file,
+            d.line !== void 0 ? `:${d.line}` : "",
+            d.column !== void 0 ? `:${d.column}` : "",
+            " "
+          ] }),
+          /* @__PURE__ */ jsxs(Text, { color: COLOR[d.level], children: [
+            d.code,
+            " "
+          ] }),
+          /* @__PURE__ */ jsx(Text, { children: d.message })
+        ] }),
+        frame.length > 0 ? /* @__PURE__ */ jsx(Text, { children: frame }) : null,
+        d.hint !== void 0 ? /* @__PURE__ */ jsxs(Text, { children: [
+          "  ",
+          /* @__PURE__ */ jsx(Text, { color: "cyan", children: "hint:" }),
+          " ",
+          d.hint
+        ] }) : null,
+        /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          "  ",
+          helpUrl(d.code)
+        ] })
+      ] }, `${d.file}:${d.line ?? "-"}:${i}`);
+    }),
+    /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { bold: true, color: errorCount > 0 ? "red" : warnCount > 0 ? "yellow" : "green", children: [
+      errorCount,
+      " ",
+      errorCount === 1 ? "error" : "errors",
+      ", ",
+      warnCount,
+      " ",
+      warnCount === 1 ? "warning" : "warnings",
+      " across ",
+      fileCount,
+      " ",
+      fileCount === 1 ? "file" : "files"
+    ] }) })
+  ] });
+}
+function formatDiagnosticsPlain(diagnostics, fileCount, sources) {
+  if (diagnostics.length === 0) {
+    return `OK: ${fileCount} ${fileCount === 1 ? "file" : "files"} checked, no diagnostics
+`;
+  }
+  const blocks = diagnostics.map((d) => {
+    const loc = d.line !== void 0 ? `${d.file}:${d.line}${d.column !== void 0 ? `:${d.column}` : ""}` : d.file;
+    const parts = [`${loc}  ${d.level}  ${d.code}  ${d.message}`];
+    const frame = frameFor(d, sources);
+    if (frame.length > 0) parts.push(frame);
+    if (d.hint !== void 0) parts.push(`  hint: ${d.hint}`);
+    return parts.join("\n");
+  });
+  const errors = diagnostics.filter((d) => d.level === "error").length;
+  const warns = diagnostics.filter((d) => d.level === "warn").length;
+  blocks.push(`${errors} error(s), ${warns} warning(s) across ${fileCount} file(s)`);
+  return blocks.join("\n\n") + "\n";
+}
+function banner(version = "0.0.1") {
+  const g = pc3.green;
+  const pit = pc3.yellow("\u25CF");
+  const name = pc3.green(pc3.bold("avodado"));
+  const ver = pc3.dim(`v${version}`);
+  const tag = pc3.dim("Documentation-as-code \u2014 Markdown with typed, fenced YAML blocks.");
+  return [
+    "",
+    `  ${g("\u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E")}`,
+    `  ${g("\u2502  ")}${pit}${g("  ")}${pit}${g("  \u2502")}   ${name} ${ver}`,
+    `  ${g("\u2502   ")}${pc3.yellow("\u25E1")}${g("   \u2502")}   ${tag}`,
+    `  ${g("\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F")}`,
+    ""
+  ].join("\n");
+}
+function examples() {
+  const step = (n, cmd, note) => `  ${pc3.dim(n)}  ${pc3.cyan(cmd.padEnd(26))}${pc3.dim(note)}`;
+  return [
+    "",
+    pc3.bold("Workflow:"),
+    step("1", "avo init", "scaffold docs/, config, and the agent skill"),
+    step("2", "edit docs/*.md", "prose + typed blocks (grammar in .avodado/skill)"),
+    step("3", "avo check", "validate \u2014 exits non-zero on errors (use in CI)"),
+    step("4", "avo preview docs/x.md", "render and open it in your browser"),
+    "",
+    `  ${pc3.dim("Per-command help:")} avo ${pc3.cyan("<command>")} --help`,
+    `  ${pc3.dim("Docs:")} https://github.com/jdiejim/avodado`,
+    ""
+  ].join("\n");
+}
+
+// src/tty.ts
+var isInteractive = process.stdout.isTTY === true && process.env["CI"] !== "true" && process.env["AVO_PLAIN"] !== "1";
+async function main(argv) {
+  const program = new Command();
+  program.name("avo").description("Author, validate, render, and export Avodado documentation.").version("0.0.1").addHelpText("beforeAll", (ctx) => ctx.command.name() === "avo" ? banner() : "").addHelpText("after", (ctx) => ctx.command.name() === "avo" ? examples() : "").exitOverride();
+  let exitCode = 0;
+  program.command("init").description("Scaffold a new Avodado project in the current directory").option("--force", "overwrite existing files").action(async (opts) => {
+    const cwd = process.cwd();
+    const result = await runInit({ cwd, ...opts.force ? { force: true } : {} });
+    for (const f of result.created) console.log(pc3.green("+ ") + f);
+    for (const f of result.skipped) console.log(pc3.dim("  skip ") + f + pc3.dim(" (exists)"));
+    console.log(
+      pc3.bold(
+        `
+Created ${result.created.length} file(s), skipped ${result.skipped.length}.
+Next: avo check`
+      )
+    );
+  });
+  program.command("new").description("Scaffold a new doc from a block template").option(
+    "--type <kind>",
+    "doc template (" + Object.keys(DOC_TEMPLATES).join(", ") + ") or block type (" + BLOCK_TYPES.join(", ") + ")"
+  ).option("--out <path>", "output file path").action(async (opts) => {
+    const cwd = process.cwd();
+    const type = opts.type;
+    if (type !== void 0 && !BLOCK_TYPES.includes(type) && !isDocTemplate(type)) {
+      console.error(pc3.red(`Unknown type: ${opts.type ?? ""}`));
+      exitCode = 2;
+      return;
+    }
+    if (!isInteractive) {
+      if (type === void 0 || opts.out === void 0) {
+        console.error(pc3.red("In non-interactive mode, both --type and --out are required."));
+        exitCode = 2;
+        return;
+      }
+      const path = await writeNewDoc({ cwd, type, out: opts.out });
+      console.log(pc3.green("\u2713 ") + "Wrote " + path);
+      return;
+    }
+    if (type !== void 0 && opts.out !== void 0) {
+      const path = await writeNewDoc({ cwd, type, out: opts.out });
+      console.log(pc3.green("\u2713 ") + "Wrote " + path);
+      return;
+    }
+    const out = opts.out ?? "./docs/new-doc.md";
+    const { waitUntilExit } = render(/* @__PURE__ */ jsx(NewApp, { cwd, out }));
+    await waitUntilExit();
+  });
+  program.command("check [globs...]").description("Validate documents (default: docs/**/*.md)").option("--json", "emit machine-readable JSON").action(async (globs, opts) => {
+    const cwd = process.cwd();
+    const config = await loadConfig(cwd);
+    const patterns = globs.length > 0 ? globs : [`${config.docsDir}/**/*.md`];
+    const result = await runCheck({ patterns, cwd, docsRoot: config.docsDir });
+    if (opts.json === true) {
+      process.stdout.write(
+        JSON.stringify({ diagnostics: result.diagnostics, files: result.files }, null, 2) + "\n"
+      );
+    } else if (isInteractive) {
+      const { waitUntilExit } = render(
+        /* @__PURE__ */ jsx(
+          DiagnosticsTable,
+          {
+            diagnostics: result.diagnostics,
+            fileCount: result.files.length,
+            sources: result.sources
+          }
+        )
+      );
+      await waitUntilExit();
+    } else {
+      process.stdout.write(
+        formatDiagnosticsPlain(result.diagnostics, result.files.length, result.sources)
+      );
+    }
+    exitCode = result.exitCode;
+  });
+  program.command("render <input>").description("Render one document to a standalone HTML file").option("-o, --output <path>", "output file path (defaults to <input>.html)").action(async (input, opts) => {
+    const cwd = process.cwd();
+    const result = await runRender({
+      cwd,
+      input,
+      ...opts.output !== void 0 ? { output: opts.output } : {}
+    });
+    if (isInteractive) {
+      const { waitUntilExit } = render(
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: "green", children: "\u2713 " }),
+          "Wrote ",
+          /* @__PURE__ */ jsx(Text, { bold: true, children: result.output }),
+          " ",
+          /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+            "(",
+            result.bytes,
+            " bytes)"
+          ] })
+        ] })
+      );
+      await waitUntilExit();
+    } else {
+      console.log(`${pc3.green("\u2713")} rendered ${result.output} ${pc3.dim(`(${result.bytes} bytes)`)}`);
+    }
+  });
+  program.command("export [globs...]").description("Batch-export documents to HTML and/or PDF").option("--format <list>", "comma-separated formats: html,pdf", "html").option("--out <dir>", "output directory (defaults to config outDir or dist)").action(async (globs, opts) => {
+    const cwd = process.cwd();
+    const config = await loadConfig(cwd);
+    const patterns = globs.length > 0 ? globs : [`${config.docsDir}/**/*.md`];
+    const formats = opts.format.split(",").map((s) => s.trim().toLowerCase()).filter((s) => s === "html" || s === "pdf");
+    if (formats.length === 0) {
+      console.error(pc3.red("No valid --format specified (expected html, pdf, or both)."));
+      exitCode = 2;
+      return;
+    }
+    const result = await runExport({
+      cwd,
+      patterns,
+      docsRoot: config.docsDir,
+      outDir: opts.out ?? config.outDir,
+      formats
+    });
+    for (const item of result.items) {
+      for (const o of item.outputs) {
+        console.log(`${pc3.green("\u2713")} ${o.path} ${pc3.dim(`(${o.bytes} bytes)`)}`);
+      }
+    }
+    console.log(pc3.bold(`
+${result.items.length} document(s) exported.`));
+  });
+  program.command("preview <input>").description("Render a document to a temp HTML file and open it").action(async (input) => {
+    const cwd = process.cwd();
+    const result = await runPreview({ cwd, input });
+    console.log(pc3.green("\u2713 ") + "Opened " + result.file);
+  });
+  const syncCmd = program.command("sync").description("Generate Avodado docs from external sources (OpenAPI)");
+  syncCmd.command("openapi <spec>").description("Generate (or drift-check) a doc from an OpenAPI 3.x spec").option("-o, --out <path>", "write generated markdown to this path").option("--check <path>", "compare against an existing doc and fail on drift").option("--slug <slug>", "block-id namespace (defaults to the output basename)").action(
+    async (spec, opts) => {
+      const result = await runSyncOpenApi({
+        cwd: process.cwd(),
+        spec,
+        ...opts.out !== void 0 ? { out: opts.out } : {},
+        ...opts.check !== void 0 ? { check: opts.check } : {},
+        ...opts.slug !== void 0 ? { slug: opts.slug } : {}
+      });
+      if (result.exitCode === 0) {
+        console.log(pc3.green("\u2713 ") + result.message);
+      } else {
+        console.error(pc3.red(result.message));
+        if (result.diff !== void 0) console.error(result.diff);
+      }
+      exitCode = result.exitCode;
+    }
+  );
+  try {
+    await program.parseAsync(argv, { from: "node" });
+  } catch (err) {
+    const e = err;
+    if (e.code === "commander.helpDisplayed" || e.code === "commander.version") {
+      return 0;
+    }
+    if (e.code === "commander.help") return 0;
+    if (typeof e.exitCode === "number" && e.code?.startsWith("commander.")) {
+      return e.exitCode;
+    }
+    console.error(pc3.red(e.message ?? String(err)));
+    return 1;
+  }
+  return exitCode;
+}
+
+// src/bin.ts
+var code = await main(process.argv);
+process.exit(code);
+//# sourceMappingURL=bin.js.map
+//# sourceMappingURL=bin.js.map