@freetesh/zeno 0.0.0-stage → 0.7.0

package/cli/dist/commands/check.js

@@ -0,0 +1,19 @@
+import { resolve } from "node:path";
+import { exitCode, formatReports } from "../format.js";
+import { findProducts, runChecks } from "../run.js";
+import { requireEstate } from "./env.js";
+export function registerCheck(program, env) {
+    program
+        .command("check")
+        .description("check that a product follows the standards (read-only)")
+        .argument("[repo]", "product repo", ".")
+        .option("--all", "check every product in the estate")
+        .option("--json", "print machine-readable JSON")
+        .option("-q, --quiet", "hide products with no findings")
+        .action((repo, options) => {
+        const repos = options.all ? findProducts(requireEstate(env)) : [resolve(repo)];
+        const reports = repos.map((path) => runChecks(path, { zenoRoot: env.zenoRoot, estateRoot: options.all ? env.estateRoot : undefined }));
+        console.log(options.json ? JSON.stringify(reports, null, 2) : formatReports(reports, { quiet: options.quiet }));
+        process.exitCode = exitCode(reports);
+    });
+}

package/cli/dist/commands/doctor.js

@@ -0,0 +1,16 @@
+import { loadConfig } from "../config/load.js";
+import { runDoctor, systemProbe } from "../doctor.js";
+export function registerDoctor(program) {
+    program
+        .command("doctor")
+        .description("check that zeno's tools, and any this repo declares, are installed")
+        .action(() => {
+        const results = runDoctor(systemProbe, loadConfig(process.cwd()).config.doctor.tools);
+        for (const result of results) {
+            const mark = result.ok ? "✓" : "✗";
+            const detail = result.ok ? (result.version ?? "") : `${result.version ?? "missing"} — ${result.hint}`;
+            console.log(`${mark} ${result.tool.padEnd(8)} ${detail}  (${result.why})`);
+        }
+        process.exitCode = results.every((result) => result.ok) ? 0 : 1;
+    });
+}

package/cli/dist/commands/env.js

@@ -0,0 +1,6 @@
+/** For commands that only make sense across products. */
+export function requireEstate(env) {
+    if (env.estateRoot)
+        return env.estateRoot;
+    throw new Error("no estate found — put `estate: true` in .claude/zeno.yaml of the folder that holds your products, or set ZENO_ESTATE");
+}

package/cli/dist/commands/init.js

@@ -0,0 +1,78 @@
+import { basename, resolve } from "node:path";
+import * as prompts from "@clack/prompts";
+import { Option } from "commander";
+import { KINDS, MODULES } from "../config/schema.js";
+import { RULES_FILES } from "../checks/architecture.js";
+import { applyInit, parseChoices, planInit } from "../init.js";
+import { listPacks } from "../packs.js";
+import { runCommand } from "../lib/system.js";
+import { zenoVersion } from "../status.js";
+function cancelled(value) {
+    if (!prompts.isCancel(value))
+        return false;
+    prompts.cancel("Nothing written.");
+    return true;
+}
+async function askAnswers(inferred, packs) {
+    const kind = await prompts.select({
+        message: "What kind of product is this?",
+        initialValue: inferred.config.kind,
+        options: KINDS.map((value) => ({ value, label: value })),
+    });
+    if (cancelled(kind))
+        return null;
+    const modules = await prompts.multiselect({
+        message: "Which modules? All optional. (docs = wiki, design = HTML designs, knowledge = search, specs, metrics, code = LSP, architecture, listing)",
+        initialValues: inferred.config.modules,
+        options: MODULES.map((value) => ({ value, label: value })),
+        required: false,
+    });
+    if (cancelled(modules))
+        return null;
+    const forKind = packs.filter((pack) => pack.kinds.includes(kind));
+    if (forKind.length === 0)
+        return { kind, modules, packs: [] };
+    const chosen = await prompts.multiselect({
+        message: "Which vendor doc packs? (indexed for search on `zeno sync`)",
+        initialValues: inferred.config.packs ?? [],
+        options: forKind.map((pack) => ({ value: pack.name, label: pack.name, hint: pack.description })),
+        required: false,
+    });
+    if (cancelled(chosen))
+        return null;
+    return { kind, modules, packs: chosen };
+}
+export function registerInit(program, env) {
+    program
+        .command("init")
+        .description("set zeno up for a product: write .claude/zeno.yaml and the missing .context files")
+        .argument("[repo]", "product repo", ".")
+        .option("-y, --yes", "accept what zeno infers (and any flags below), no questions")
+        .addOption(new Option("--kind <kind>", "product kind").choices(KINDS))
+        .option("--modules <list>", `comma list, empty for none: ${MODULES.join(", ")}`)
+        .option("--packs <list>", "comma list of vendor doc packs (see `zeno add`)")
+        .option("--force", "redo a repo that already has zeno.yaml")
+        .action(async (repo, options) => {
+        const path = resolve(repo);
+        const packs = listPacks(env.zenoRoot);
+        const flags = {
+            zenoVersion: zenoVersion(env.zenoRoot),
+            force: options.force,
+            kind: options.kind,
+            modules: options.modules === undefined ? undefined : parseChoices(options.modules, MODULES, "module"),
+            packs: options.packs === undefined ? undefined : parseChoices(options.packs, packs.map((p) => p.name), "pack"),
+        };
+        const inferred = planInit(path, flags);
+        const answers = options.yes ? null : await askAnswers(inferred, packs);
+        if (!options.yes && answers === null)
+            return;
+        const plan = answers ? planInit(path, { ...flags, ...answers }) : inferred;
+        applyInit(path, plan, { name: basename(path), zenoRoot: env.zenoRoot, run: (command, args) => void runCommand(command, args) });
+        console.log(`wrote .claude/zeno.yaml (${plan.config.kind}: ${plan.config.modules.join(", ")})`);
+        for (const file of plan.create)
+            console.log(`created ${file}`);
+        if (plan.create.some((file) => file.endsWith(RULES_FILES[0])))
+            console.log("architecture: add the checker with `pnpm add -D dependency-cruiser`, then edit the .dependency-cruiser.cjs files to this repo's layers");
+        console.log(plan.config.packs ? "next: zeno sync (fetches the packs), then zeno check" : "next: zeno check");
+    });
+}

package/cli/dist/commands/learn.js

@@ -0,0 +1,35 @@
+import { proposals, readDecisions, readVerdicts, recordDecision } from "../learn.js";
+import { findProducts } from "../run.js";
+import { requireEstate } from "./env.js";
+const DEFAULT_THRESHOLD = 3;
+export function registerLearn(program, env) {
+    program
+        .command("learn")
+        .description("turn overridden verdicts across products into proposals to change the rules")
+        .option("--threshold <n>", "overrides of one principle before it is proposed", String(DEFAULT_THRESHOLD))
+        .option("--approve <id>", "mark a proposal approved (then edit the standard)")
+        .option("--reject <id>", "mark a proposal rejected; it returns only with new evidence")
+        .option("--note <text>", "why, for --approve / --reject", "")
+        .action((options) => {
+        const estateRoot = requireEstate(env);
+        const entries = readVerdicts(findProducts(estateRoot));
+        const found = proposals(entries, { threshold: Number(options.threshold), decisions: readDecisions(estateRoot) });
+        const target = options.approve ?? options.reject;
+        if (target) {
+            const proposal = found.find((p) => p.id === target);
+            if (!proposal)
+                throw new Error(`no open proposal "${target}" — run \`zeno learn\` to list them`);
+            recordDecision(estateRoot, { id: target, decision: options.approve ? "approved" : "rejected", count: proposal.count, note: options.note });
+            console.log(`${options.approve ? "approved" : "rejected"} ${target}`);
+            return;
+        }
+        console.log(`${entries.length} overridden verdict(s) logged across the estate`);
+        if (found.length === 0)
+            console.log("no proposals");
+        for (const proposal of found) {
+            console.log(`\n${proposal.id}\n  ${proposal.summary}\n  products: ${proposal.products.join(", ")}`);
+            for (const reason of proposal.reasons)
+                console.log(`  - "${reason}"`);
+        }
+    });
+}

package/cli/dist/commands/standards.js

@@ -0,0 +1,26 @@
+import { resolve } from "node:path";
+import { loadConfig } from "../config/load.js";
+import { constitutionTitles, resolveStandards } from "../standards.js";
+export function registerStandards(program, env) {
+    program
+        .command("standards")
+        .description("list the standards that apply to a repo: zeno's defaults, then the estate's and the repo's")
+        .argument("[repo]", "product repo", ".")
+        .option("--json", "print machine-readable JSON")
+        .option("--constitution", "print only the principle titles, zeno's then any added ones")
+        .action((repo, options) => {
+        const { config } = loadConfig(resolve(repo));
+        if (options.constitution) {
+            const titles = constitutionTitles(env.zenoRoot, config.standards);
+            console.log(options.json ? JSON.stringify(titles) : titles.map((title) => `- ${title}`).join("\n"));
+            return;
+        }
+        const standards = resolveStandards(env.zenoRoot, config.standards);
+        if (options.json) {
+            console.log(JSON.stringify(standards, null, 2));
+            return;
+        }
+        for (const standard of standards)
+            console.log(`${standard.name.padEnd(18)} ${standard.path}`);
+    });
+}

package/cli/dist/commands/status.js

@@ -0,0 +1,11 @@
+import { resolve } from "node:path";
+import { buildStatus } from "../status.js";
+export function registerStatus(program, env) {
+    program
+        .command("status")
+        .description("one screen: zeno version, config, check summary")
+        .argument("[repo]", "product repo", ".")
+        .action((repo) => {
+        console.log(buildStatus(resolve(repo), { zenoRoot: env.zenoRoot }));
+    });
+}

package/cli/dist/commands/sync.js

@@ -0,0 +1,23 @@
+import { resolve } from "node:path";
+import { exitCode, formatReports } from "../format.js";
+import { CACHE_DIR, fetchText, runCommand } from "../lib/system.js";
+import { runChecks } from "../run.js";
+import { syncRepo } from "../sync.js";
+export function registerSync(program, env) {
+    program
+        .command("sync")
+        .description("refresh pack docs and the search index, move the pinned zeno version, then check")
+        .argument("[repo]", "product repo", ".")
+        .action(async (repo) => {
+        const path = resolve(repo);
+        const result = await syncRepo(path, { zenoRoot: env.zenoRoot, estateRoot: env.estateRoot ?? undefined, cacheDir: CACHE_DIR, fetchText, run: runCommand });
+        console.log(`packs refreshed: ${result.packs.join(", ") || "none"}`);
+        if (result.base)
+            console.log("architecture base updated from zeno's template");
+        if (result.version)
+            console.log(`zeno ${result.version.from ?? "unpinned"} → ${result.version.to}`);
+        const report = runChecks(path, { zenoRoot: env.zenoRoot });
+        console.log(formatReports([report]));
+        process.exitCode = exitCode([report]);
+    });
+}

package/cli/dist/commands/ui.js

@@ -0,0 +1,64 @@
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { architectureGraph } from "../checks/architecture.js";
+import { formatReports } from "../format.js";
+import { CACHE_DIR } from "../lib/system.js";
+import { findProducts, runChecks } from "../run.js";
+import { buildSite, quartzConfig } from "../ui.js";
+import { requireEstate } from "./env.js";
+// Quartz v5 has no tagged release yet, so pin the exact commit: an unpinned
+// clone could change the site under us on the next fresh install.
+const QUARTZ_REPO = "https://github.com/jackyzha0/quartz";
+const QUARTZ_COMMIT = "97a2d05f80c4c50534959b1d0d41cc4b3895625e";
+const QUARTZ_DIR = join(CACHE_DIR, "quartz");
+function must(command, args, cwd) {
+    const result = spawnSync(command, args, { cwd, stdio: "inherit" });
+    if (result.status !== 0)
+        throw new Error(`${command} ${args.join(" ")} failed`);
+}
+function ensureQuartz() {
+    if (!existsSync(join(QUARTZ_DIR, "node_modules"))) {
+        if (!existsSync(QUARTZ_DIR))
+            must("git", ["clone", "--quiet", "--filter=blob:none", QUARTZ_REPO, QUARTZ_DIR]);
+        must("git", ["checkout", "--quiet", QUARTZ_COMMIT], QUARTZ_DIR);
+        must("npm", ["ci", "--silent"], QUARTZ_DIR);
+    }
+    const defaults = readFileSync(join(QUARTZ_DIR, "quartz.config.default.yaml"), "utf8");
+    writeFileSync(join(QUARTZ_DIR, "quartz.config.yaml"), quartzConfig(defaults));
+}
+export function registerUi(program, env) {
+    program
+        .command("ui")
+        .description("serve every product wiki (search, backlinks, graph) and the design galleries on localhost")
+        // Uncommon defaults: 8080 and 3001 are usually taken by Docker or a dev server.
+        .option("--port <port>", "wiki site port", "4610")
+        .option("--designs-port <port>", "design gallery port", "4611")
+        .option("--ws-port <port>", "live-reload socket port", "4612")
+        .action((options) => {
+        ensureQuartz();
+        const products = findProducts(requireEstate(env));
+        const siteDir = join(CACHE_DIR, "site");
+        const designsDir = join(CACHE_DIR, "designs");
+        const designsUrl = `http://127.0.0.1:${options.designsPort}`;
+        const report = formatReports(products.map((repo) => runChecks(repo, { zenoRoot: env.zenoRoot, estateRoot: env.estateRoot })));
+        buildSite(products, { siteDir, designsDir, designsUrl, report, graph: architectureGraph });
+        const designs = spawn("python3", ["-m", "http.server", options.designsPort, "--bind", "127.0.0.1", "--directory", designsDir], {
+            stdio: "ignore",
+        });
+        const site = spawn("npx", ["quartz", "build", "-d", siteDir, "-o", join(CACHE_DIR, "public"), "--serve", "--port", options.port, "--wsPort", options.wsPort], {
+            cwd: QUARTZ_DIR,
+            stdio: "inherit",
+        });
+        console.log(`wiki    http://localhost:${options.port}\ndesigns ${designsUrl}`);
+        const stop = () => {
+            designs.kill();
+            site.kill();
+        };
+        process.on("SIGINT", stop);
+        site.on("exit", (code) => {
+            designs.kill();
+            process.exitCode = code ?? 0;
+        });
+    });
+}

package/cli/dist/commands/weigh.js

@@ -0,0 +1,16 @@
+import { spawnSync } from "node:child_process";
+export function registerWeigh(program) {
+    program
+        .command("weigh")
+        .description("run the decision gate on a request without doing it (calls Claude)")
+        .argument("<request...>", "what you want to do")
+        .action((words) => {
+        const request = words.join(" ");
+        const result = spawnSync("claude", ["-p", `/zeno:weigh ${request}\n\nWeigh only. Do not start the work.`], {
+            stdio: "inherit",
+        });
+        if (result.error)
+            throw new Error(`could not run claude: ${result.error.message}`);
+        process.exitCode = result.status ?? 1;
+    });
+}

package/cli/dist/config/load.js

@@ -0,0 +1,93 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { parse } from "yaml";
+import { MODULES_BY_KIND, layerSchema } from "./schema.js";
+const EXPO_MARKERS = ["app.config.ts", "app.config.js", "app.json"];
+const WEB_MARKERS = ["next.config.ts", "next.config.js", "next.config.mjs", "vite.config.ts"];
+function configPath(folder) {
+    return join(folder, ".claude", "zeno.yaml");
+}
+function readLayer(path) {
+    const parsed = layerSchema.safeParse(parse(readFileSync(path, "utf8")) ?? {});
+    if (!parsed.success) {
+        const problems = parsed.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`);
+        throw new Error(`${path} is invalid:\n  ${problems.join("\n  ")}`);
+    }
+    return parsed.data;
+}
+/** The nearest folder at or above `start` whose zeno.yaml says `estate: true`, or null. */
+export function findEstate(start) {
+    let folder = resolve(start);
+    while (true) {
+        const path = configPath(folder);
+        if (existsSync(path) && readLayer(path).estate === true)
+            return folder;
+        const parent = dirname(folder);
+        if (parent === folder)
+            return null;
+        folder = parent;
+    }
+}
+/** The repo root plus each app in a monorepo's apps/ folder. */
+function appRoots(repo) {
+    const apps = join(repo, "apps");
+    if (!existsSync(apps))
+        return [repo];
+    const children = readdirSync(apps, { withFileTypes: true }).filter((entry) => entry.isDirectory());
+    return [repo, ...children.map((entry) => join(apps, entry.name))];
+}
+export function inferKind(repo) {
+    const roots = appRoots(repo);
+    const anyHas = (markers) => roots.some((root) => markers.some((file) => existsSync(join(root, file))));
+    if (anyHas(EXPO_MARKERS))
+        return "expo-app";
+    if (anyHas(WEB_MARKERS))
+        return "web";
+    return "content";
+}
+export function inferModules(repo, kind) {
+    const modules = MODULES_BY_KIND[kind];
+    const hasDesigns = existsSync(join(repo, ".context", "designs"));
+    return hasDesigns && !modules.includes("design") ? [...modules, "design"] : modules;
+}
+function lastDefined(values) {
+    return values.filter((value) => value !== undefined).pop();
+}
+function mergeBy(lists, key) {
+    const merged = new Map();
+    for (const item of lists.flat())
+        merged.set(key(item), item);
+    return [...merged.values()];
+}
+/**
+ * Reads the estate, product and local zeno.yaml layers over defaults inferred
+ * from the repo. Scalars: the most specific layer wins. Lists of names add up
+ * (packs, standards); lists of records merge by their key (commands, tools).
+ */
+export function loadConfig(repo, options = {}) {
+    const estateRoot = options.estateRoot === undefined ? findEstate(dirname(resolve(repo))) : options.estateRoot;
+    const candidates = [
+        ...(estateRoot && resolve(estateRoot) !== resolve(repo) ? [{ layer: "estate", path: configPath(estateRoot) }] : []),
+        { layer: "product", path: configPath(repo) },
+        { layer: "local", path: join(repo, ".claude", "zeno.local.yaml") },
+    ];
+    const sources = candidates.filter((source) => existsSync(source.path));
+    const layers = sources.map((source) => ({ data: readLayer(source.path), base: dirname(dirname(source.path)) }));
+    const pick = (key) => layers.map((layer) => layer.data[key]);
+    const kind = lastDefined(pick("kind")) ?? inferKind(repo);
+    const config = {
+        zeno: lastDefined(pick("zeno")),
+        kind,
+        modules: lastDefined(pick("modules")) ?? inferModules(repo, kind),
+        expo: Object.assign({}, ...pick("expo")),
+        packs: [...new Set(pick("packs").flatMap((packs) => packs ?? []))].sort(),
+        standards: [...new Set(layers.flatMap((layer) => (layer.data.standards ?? []).map((dir) => resolve(layer.base, dir))))],
+        commands: mergeBy(pick("commands").map((list) => list ?? []), (command) => command.id),
+        doctor: { tools: mergeBy(pick("doctor").map((doctor) => doctor?.tools ?? []), (tool) => tool.tool) },
+        checks: Object.assign({}, ...pick("checks")),
+        weigh: { weights: Object.assign({}, ...pick("weigh").map((weigh) => weigh?.weights)) },
+    };
+    if (Object.keys(config.expo ?? {}).length === 0)
+        delete config.expo;
+    return { config, sources };
+}

package/cli/dist/config/schema.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+export const KINDS = ["expo-app", "web", "content"];
+export const MODULES = ["docs", "design", "knowledge", "specs", "metrics", "code", "architecture", "listing"];
+const checkOverride = z
+    .object({ enabled: z.boolean().default(true), reason: z.string().min(1).optional() })
+    .refine((check) => check.enabled || check.reason !== undefined, {
+    message: "a check turned off needs a `reason:` — an override nobody can explain is drift",
+});
+const principleId = z.string().regex(/^C-\d{2}$/, "principle IDs look like C-07");
+const command = z
+    .object({
+    id: z.string().regex(/^[a-z0-9-]+$/),
+    /** Shell command run from the repo root; a non-zero exit is an error finding. */
+    run: z.string().min(1),
+    /** Only run when this path exists in the repo. */
+    if: z.string().optional(),
+})
+    .strict();
+const tool = z.object({ tool: z.string(), why: z.string(), hint: z.string() }).strict();
+/** One layer of `.claude/zeno.yaml` as written: every field optional. */
+export const layerSchema = z
+    .object({
+    /** Marks the folder holding this file as an estate: the parent of several products. */
+    estate: z.boolean(),
+    zeno: z.string(),
+    kind: z.enum(KINDS),
+    modules: z.array(z.enum(MODULES)),
+    expo: z.object({ sdk: z.number().int().positive() }).partial(),
+    packs: z.array(z.string().regex(/^[a-z0-9-]+$/, "pack names are lowercase-kebab")),
+    /** Folders of extra standards, relative to the folder that holds `.claude/`. */
+    standards: z.array(z.string()),
+    commands: z.array(command),
+    doctor: z.object({ tools: z.array(tool) }).partial(),
+    checks: z.record(z.string(), checkOverride),
+    weigh: z.object({ weights: z.record(principleId, z.number().nonnegative()) }).partial(),
+})
+    .partial()
+    .strict();
+export const MODULES_BY_KIND = {
+    "expo-app": ["docs", "knowledge", "metrics", "code", "listing"],
+    web: ["docs", "knowledge", "metrics", "code"],
+    content: ["docs", "knowledge"],
+};

package/cli/dist/doctor.js

@@ -0,0 +1,31 @@
+import { spawnSync } from "node:child_process";
+// What zeno itself needs. A repo or estate adds its own under `doctor.tools`.
+const CORE_TOOLS = [
+    { tool: "node", why: "runs the zeno CLI and hooks", hint: "install Node 22+", minimum: [22, 0] },
+    { tool: "git", why: "zeno works on git repos", hint: "install git" },
+    { tool: "qmd", why: "knowledge search for Claude", hint: "npm i -g @tobilu/qmd (see the zeno README)" },
+];
+const VERSION = /(\d+)\.(\d+)(?:\.(\d+))?/;
+export const systemProbe = (command) => {
+    const result = spawnSync(command, ["--version"], { encoding: "utf8" });
+    if (result.error || result.status !== 0)
+        return null;
+    return `${result.stdout}${result.stderr}`.trim().split("\n")[0];
+};
+export function runDoctor(probe = systemProbe, extra = []) {
+    const tools = [...CORE_TOOLS, ...extra];
+    return tools.map(({ tool, why, hint, minimum }) => {
+        const output = probe(tool);
+        if (output === null)
+            return { tool, ok: false, why, hint };
+        const match = VERSION.exec(output);
+        const version = match?.[0];
+        if (minimum && match) {
+            const [major, minor] = [Number(match[1]), Number(match[2])];
+            const tooOld = major < minimum[0] || (major === minimum[0] && minor < minimum[1]);
+            if (tooOld)
+                return { tool, ok: false, version, why, hint };
+        }
+        return { tool, ok: true, version, why };
+    });
+}

package/cli/dist/format.js

@@ -0,0 +1,37 @@
+const MARK = { error: "✗", warn: "!" };
+function plural(count, word) {
+    return `${count} ${word}${count === 1 ? "" : "s"}`;
+}
+function counts(report) {
+    return {
+        errors: report.findings.filter((f) => f.level === "error").length,
+        warnings: report.findings.filter((f) => f.level === "warn").length,
+    };
+}
+/** Compact, rtk-style text: one header per product, one line per finding, one total line. */
+export function formatReports(reports, options = {}) {
+    const lines = [];
+    let errors = 0;
+    let warnings = 0;
+    for (const report of reports) {
+        const count = counts(report);
+        errors += count.errors;
+        warnings += count.warnings;
+        const clean = report.findings.length === 0;
+        if (clean && options.quiet && report.overrides.length === 0)
+            continue;
+        const summary = clean ? "ok" : `${plural(count.errors, "error")}, ${plural(count.warnings, "warning")}`;
+        lines.push(`${report.name}  ${summary}`);
+        for (const finding of report.findings) {
+            const message = finding.message.replace(/\n/g, "\n      ");
+            lines.push(`  ${MARK[finding.level]} ${finding.check}  ${finding.file ?? ""}  ${message}`.replace(/  +$/, ""));
+        }
+        for (const override of report.overrides)
+            lines.push(`  override ${override.check}: ${override.reason}`);
+    }
+    lines.push(`${plural(reports.length, "product")} · ${plural(errors, "error")} · ${plural(warnings, "warning")}`);
+    return lines.join("\n");
+}
+export function exitCode(reports) {
+    return reports.some((report) => report.findings.some((f) => f.level === "error")) ? 1 : 0;
+}

package/cli/dist/index.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { Command } from "commander";
+import { registerAdd } from "./commands/add.js";
+import { registerCheck } from "./commands/check.js";
+import { registerDoctor } from "./commands/doctor.js";
+import { registerInit } from "./commands/init.js";
+import { registerLearn } from "./commands/learn.js";
+import { registerStandards } from "./commands/standards.js";
+import { registerStatus } from "./commands/status.js";
+import { registerSync } from "./commands/sync.js";
+import { registerUi } from "./commands/ui.js";
+import { registerWeigh } from "./commands/weigh.js";
+import { findEstate } from "./config/load.js";
+import { zenoVersion } from "./status.js";
+const env = {
+    zenoRoot: resolve(import.meta.dirname, "..", ".."),
+    estateRoot: process.env.ZENO_ESTATE ?? findEstate(process.cwd()),
+};
+const program = new Command("zeno")
+    .description("Shared standards, knowledge and decision checks for every product.")
+    .version(zenoVersion(env.zenoRoot));
+registerInit(program, env);
+registerAdd(program, env);
+registerCheck(program, env);
+registerSync(program, env);
+registerStatus(program, env);
+registerStandards(program, env);
+registerDoctor(program);
+registerUi(program, env);
+registerLearn(program, env);
+registerWeigh(program);
+program.parseAsync().catch((error) => {
+    console.error(`zeno: ${error.message}`);
+    process.exitCode = 1;
+});