@invariant-ui/cli 0.0.0-stage → 0.1.0

package/dist/cli/commands-discover.js

@@ -0,0 +1,312 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { globToRegExp } from "../compiler-core/index.js";
+import { DesignSystem } from "../contract-query/index.js";
+import { PATTERNS_FILE, parsePatterns } from "../governance/index.js";
+import { applyReviews, CANDIDATE_KINDS, CANDIDATE_STATUSES, CANDIDATES_FILE, candidatesFileSchema, DEFAULT_OPTIONS, discover, emptyReviews, latestReview, parseReviews, REVIEWS_FILE, recordReview, serializeReviews, toDefinition } from "../validation/index.js";
+import { json, outputDir, print, writableDir } from "./commands.js";
+import { collect } from "./commands-validate.js";
+import { loadConfig } from "./config.js";
+import { CliError } from "./errors.js";
+import { table } from "./format.js";
+import { loadCompiled } from "./store.js";
+import { CLI_NAME } from "./version.js";
+const DISCOVER_USAGE = `usage: ${CLI_NAME} discover <path...> [--min-files n] [--min-uses n] [--similarity 0-1] [--depth n] [--json]
+Finds structures that recur in your application code and writes them to ${CANDIDATES_FILE} as candidates to review.
+Nothing it finds is approved or enforced.`;
+const CANDIDATES_USAGE = `usage: ${CLI_NAME} candidates <list|show|accept|reject|defer|promote> ...
+  candidates list [--status s] [--kind k] [--all]
+  candidates show <id>
+  candidates accept|reject|defer <id> --as <name> [--note why] [--reference ref]
+  candidates promote <id> --id <pattern id> --as <name> [--name n] [--category c] [--dry-run]`;
+function integer(name, value, fallback, min, max) {
+    if (value === undefined)
+        return fallback;
+    const n = Number(value);
+    if (!Number.isInteger(n) || n < min || n > max)
+        throw new CliError(`--${name} must be a whole number from ${min} to ${max}`);
+    return n;
+}
+function similarityOption(value) {
+    if (value === undefined)
+        return DEFAULT_OPTIONS.similarity;
+    const n = Number(value);
+    if (!Number.isFinite(n) || n <= 0 || n > 1)
+        throw new CliError("--similarity must be a number above 0 and up to 1");
+    return n;
+}
+const read = (file) => (existsSync(file) ? readFileSync(file, "utf8") : undefined);
+async function reviewsPath(c) {
+    const loaded = await loadConfig({
+        cwd: c.cwd,
+        file: c.args.values.config,
+        trustConfig: c.args.values["trust-config"] === true
+    });
+    return path.resolve(c.cwd, loaded?.config.governance?.candidateReviewsFile ?? REVIEWS_FILE);
+}
+function loadReviews(file) {
+    const text = read(file);
+    if (text === undefined)
+        return undefined;
+    const parsed = parseReviews(text, path.basename(file));
+    if (!parsed.ok)
+        throw new CliError(parsed.message, 2);
+    return parsed.value;
+}
+/** `invariant discover <paths...>`: finds recurring structures and writes them as candidates. */
+export async function discoverCommand(c) {
+    const targets = c.args.positionals.slice(1);
+    if (targets.length === 0)
+        throw new CliError(DISCOVER_USAGE);
+    const options = {
+        minFiles: integer("min-files", c.args.values["min-files"], DEFAULT_OPTIONS.minFiles, 2, 1000),
+        minUses: integer("min-uses", c.args.values["min-uses"], DEFAULT_OPTIONS.minUses, 2, 10000),
+        similarity: similarityOption(c.args.values.similarity),
+        maxDepth: integer("depth", c.args.values.depth, DEFAULT_OPTIONS.maxDepth, 1, 6)
+    };
+    const loaded = await loadConfig({
+        cwd: c.cwd,
+        file: c.args.values.config,
+        trustConfig: c.args.values["trust-config"] === true
+    });
+    const contractFolder = await outputDir(c);
+    const dir = await writableDir(c);
+    const { contract, evidence } = loadCompiled(contractFolder);
+    const ds = new DesignSystem(contract, evidence);
+    const ignore = (loaded?.config.validation?.ignore ?? []).map((g) => globToRegExp(g));
+    const found = [];
+    for (const t of targets)
+        collect(c.cwd, t, ignore, found);
+    const files = [...new Set(found)]
+        .sort()
+        .map((file) => ({ file, code: readFileSync(path.resolve(c.cwd, file), "utf8") }));
+    const result = discover({ ds, files, options, reviews: loadReviews(await reviewsPath(c)) });
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(path.join(dir, CANDIDATES_FILE), `${JSON.stringify(result, null, 2)}\n`);
+    if (c.args.values.json)
+        json(c, result);
+    else
+        print(c, summaryText(result, c.args.values.all === true));
+    return 0;
+}
+function summaryText(result, all) {
+    const shown = result.candidates.filter((x) => all || x.subsumedBy === undefined);
+    const lines = [
+        `${result.summary.filesAnalyzed} of ${result.summary.files} files analyzed, ${result.candidates.length} candidates written to ${CANDIDATES_FILE}`
+    ];
+    for (const d of result.diagnostics)
+        lines.push(`${d.severity}: ${d.message}`);
+    if (shown.length > 0)
+        lines.push("", listTable(shown));
+    lines.push("", `Candidates are observations, not approved patterns. Review one with \`${CLI_NAME} candidates show <id>\`.`);
+    return lines.join("\n");
+}
+const listTable = (candidates) => table(["id", "kind", "status", "files", "uses", "name"], candidates.map((x) => [
+    x.id.replace("candidate:", ""),
+    x.kind,
+    x.status,
+    x.support.files,
+    x.support.occurrences,
+    x.suggestedName
+]));
+/** Candidates as last discovered, with the decisions recorded since applied. */
+async function loadCandidates(c) {
+    const dir = await writableDir(c);
+    const text = read(path.join(dir, CANDIDATES_FILE));
+    if (text === undefined)
+        throw new CliError(`no ${CANDIDATES_FILE} in ${dir}. Run \`${CLI_NAME} discover <path...>\` first.`);
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch {
+        throw new CliError(`${CANDIDATES_FILE} is not valid JSON; run discover again`, 1);
+    }
+    const parsed = candidatesFileSchema.safeParse(raw);
+    if (!parsed.success)
+        throw new CliError(`${CANDIDATES_FILE} does not match its schema; run discover again`, 1);
+    const reviews = loadReviews(await reviewsPath(c));
+    const applied = applyReviews(parsed.data.candidates.map((x) => {
+        const { review: _, ...rest } = x;
+        return { ...rest, status: "proposed" };
+    }), reviews);
+    let stale = false;
+    try {
+        stale =
+            loadCompiled(await outputDir(c)).contract.integrity.contentHash !== parsed.data.contract.contentHash;
+    }
+    catch {
+        stale = false;
+    }
+    return { file: parsed.data, candidates: applied.candidates, stale, dir };
+}
+function find(candidates, query) {
+    if (!query)
+        throw new CliError(CANDIDATES_USAGE);
+    const q = query.replace(/^candidate:/, "");
+    const exact = candidates.filter((x) => x.id === `candidate:${q}`);
+    const hits = exact.length > 0
+        ? exact
+        : candidates.filter((x) => x.id.replace("candidate:", "").endsWith(q) ||
+            x.id.replace("candidate:", "").split(".")[1]?.startsWith(q));
+    if (hits.length === 1)
+        return hits[0];
+    if (hits.length === 0)
+        throw new CliError(`no candidate matches "${query}". List them with \`${CLI_NAME} candidates list --all\`.`);
+    throw new CliError(`"${query}" matches several candidates: ${hits.map((x) => x.id).join(", ")}. Use the full id.`);
+}
+function show(c, x) {
+    if (c.args.values.json) {
+        json(c, x);
+        return;
+    }
+    print(c, `${x.suggestedName}  (${x.id})`);
+    print(c, `kind: ${x.kind}   status: ${x.status}   basis: ${x.basis}   equivalence: ${x.equivalence}`);
+    print(c, `found in ${x.support.files} files, ${x.support.occurrences} places`);
+    if (x.consistency)
+        print(c, `overlap between files: lowest ${x.consistency.minimumPairwise}, mean ${x.consistency.meanPairwise}`);
+    if (x.subsumedBy)
+        print(c, `inside a larger candidate: ${x.subsumedBy}`);
+    print(c, `\n${x.summary}`);
+    print(c, "\nwhy it was found");
+    for (const line of x.explanation)
+        print(c, `  ${line}`);
+    if (x.structure.common.length > 0)
+        print(c, `\nin every file\n  ${x.structure.common.join("\n  ")}`);
+    if (x.structure.frequent.length > 0)
+        print(c, `\nin most files\n  ${x.structure.frequent.map((f) => `${f.feature} (${f.files})`).join("\n  ")}`);
+    if (x.structure.variable.length > 0)
+        print(c, `\nvaries\n  ${x.structure.variable.map((f) => `${f.feature} (${f.files})`).join("\n  ")}${x.structure.variableTruncated ? "\n  ..." : ""}`);
+    if (x.kind === "arrangement")
+        print(c, `\nform: ${x.structure.key}`);
+    print(c, `\nevidence${x.evidenceTruncated ? ` (first ${x.evidence.length} of ${x.support.occurrences})` : ""}`);
+    for (const e of x.evidence)
+        print(c, `  ${e.file}:${e.line}:${e.column}  ${e.detail}`);
+    if (x.review)
+        print(c, `\n${x.review.decision} by ${x.review.decidedBy} on ${x.review.decidedAt}${x.review.reason ? `: ${x.review.reason}` : ""}${x.review.promotedTo ? `\npromoted to ${x.review.promotedTo}` : ""}`);
+    else
+        print(c, `\nNo decision recorded. \`${CLI_NAME} candidates accept ${x.id.replace("candidate:", "")} --as <name>\``);
+}
+async function who(c) {
+    const loaded = await loadConfig({
+        cwd: c.cwd,
+        file: c.args.values.config,
+        trustConfig: c.args.values["trust-config"] === true
+    });
+    const by = c.args.values.as ?? c.io.env?.INVARIANT_USER;
+    if (!by || by.trim() === "")
+        throw new CliError("say who is deciding: --as <name> (or set INVARIANT_USER). Names are recorded, not authenticated.");
+    const approvers = loaded?.config.governance?.approvers;
+    if (approvers && approvers.length > 0 && !approvers.includes(by))
+        throw new CliError(`"${by}" is not listed in governance.approvers`);
+    return by;
+}
+const DECISION_OF = { accept: "accepted", reject: "rejected", defer: "deferred" };
+async function decide(c, sub, id) {
+    const { candidates } = await loadCandidates(c);
+    const x = find(candidates, id);
+    const by = await who(c);
+    const file = await reviewsPath(c);
+    const next = recordReview(loadReviews(file) ?? emptyReviews(), {
+        candidate: x.id,
+        decision: DECISION_OF[sub],
+        decidedBy: by,
+        decidedAt: c.io.clock(),
+        ...(c.args.values.note ? { reason: c.args.values.note } : {}),
+        ...(c.args.values.reference ? { reference: c.args.values.reference } : {})
+    });
+    writeFileSync(file, serializeReviews(next));
+    print(c, `${DECISION_OF[sub]} ${x.id}, recorded in ${path.basename(file)}${sub === "accept" ? `. To add it to your definitions: ${CLI_NAME} candidates promote ${x.id.replace("candidate:", "")} --id <pattern id> --as ${by}` : ""}`);
+    return 0;
+}
+async function promote(c, id) {
+    const { candidates } = await loadCandidates(c);
+    const x = find(candidates, id);
+    if (x.status !== "accepted")
+        throw new CliError(`${x.id} is ${x.status}. Accept it first: ${CLI_NAME} candidates accept ${x.id.replace("candidate:", "")} --as <name>`);
+    const patternId = c.args.values.id;
+    if (!patternId)
+        throw new CliError(`give the pattern an id: --id <id>, such as composition.card-with-header\n${CANDIDATES_USAGE}`);
+    const by = await who(c);
+    const loaded = await loadConfig({
+        cwd: c.cwd,
+        file: c.args.values.config,
+        trustConfig: c.args.values["trust-config"] === true
+    });
+    const patternsFile = path.resolve(c.cwd, loaded?.config.governance?.patternsFile ?? PATTERNS_FILE);
+    const text = read(patternsFile);
+    let doc = { version: 1, patterns: [] };
+    if (text !== undefined) {
+        try {
+            doc = JSON.parse(text);
+        }
+        catch {
+            throw new CliError(`${path.basename(patternsFile)} is not valid JSON`, 2);
+        }
+        if (!Array.isArray(doc.patterns))
+            throw new CliError(`${path.basename(patternsFile)} has no "patterns" list`, 2);
+    }
+    const definition = toDefinition(x, {
+        id: patternId,
+        name: c.args.values.name,
+        category: c.args.values.category
+    });
+    const bare = (s) => s.replace(/^pattern:/, "");
+    if ((doc.patterns ?? []).some((p) => typeof p.id === "string" && bare(p.id) === bare(patternId)))
+        throw new CliError(`${path.basename(patternsFile)} already has a pattern "${patternId}"`);
+    const next = { ...doc, patterns: [...(doc.patterns ?? []), definition] };
+    const check = parsePatterns(JSON.stringify(next), path.basename(patternsFile));
+    if (!check.ok)
+        throw new CliError(`the definition is not valid: ${check.message}`, 2);
+    if (c.args.values["dry-run"]) {
+        json(c, definition);
+        return 0;
+    }
+    writeFileSync(patternsFile, `${JSON.stringify(next, null, 2)}\n`);
+    const reviewFile = await reviewsPath(c);
+    const prior = latestReview(loadReviews(reviewFile) ?? emptyReviews(), x.id);
+    writeFileSync(reviewFile, serializeReviews(recordReview(loadReviews(reviewFile) ?? emptyReviews(), {
+        candidate: x.id,
+        decision: "accepted",
+        decidedBy: by,
+        decidedAt: c.io.clock(),
+        ...(prior?.reason ? { reason: prior.reason } : {}),
+        ...(prior?.reference ? { reference: prior.reference } : {}),
+        promotedTo: patternId
+    })));
+    print(c, `added ${patternId} to ${path.basename(patternsFile)}. It has no approval, intent or constraints. Run \`${CLI_NAME} compile\`, then approve it with \`${CLI_NAME} review\` or add an approval block, once you have read it.`);
+    return 0;
+}
+/** `invariant candidates ...`: review what discovery found. */
+export async function candidatesCommand(c) {
+    const [, sub, id] = c.args.positionals;
+    if (!sub || !["list", "show", "accept", "reject", "defer", "promote"].includes(sub))
+        throw new CliError(CANDIDATES_USAGE);
+    if (sub === "accept" || sub === "reject" || sub === "defer")
+        return decide(c, sub, id);
+    if (sub === "promote")
+        return promote(c, id);
+    const loaded = await loadCandidates(c);
+    if (sub === "show") {
+        show(c, find(loaded.candidates, id));
+        return 0;
+    }
+    const status = c.args.values.status;
+    if (status && !CANDIDATE_STATUSES.includes(status))
+        throw new CliError(`--status must be one of: ${CANDIDATE_STATUSES.join(", ")}`);
+    const kind = c.args.values.kind;
+    if (kind && !CANDIDATE_KINDS.includes(kind))
+        throw new CliError(`--kind must be one of: ${CANDIDATE_KINDS.join(", ")}`);
+    const shown = loaded.candidates.filter((x) => (!status || x.status === status) &&
+        (!kind || x.kind === kind) &&
+        (c.args.values.all || x.subsumedBy === undefined));
+    if (c.args.values.json)
+        json(c, shown);
+    else {
+        if (loaded.stale)
+            print(c, `note: the contract has changed since discovery ran. Run \`${CLI_NAME} discover\` again.`);
+        print(c, shown.length === 0 ? "no candidates match" : listTable(shown));
+    }
+    return 0;
+}
+//# sourceMappingURL=commands-discover.js.map

package/dist/cli/commands-enforcement.js

@@ -0,0 +1,35 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { readEvents } from "./enforcement-log.js";
+import { renderHtml, renderText, summarize } from "./enforcement-report.js";
+import { CliError } from "./errors.js";
+/**
+ * `invariant enforcement report`: the session timeline from the enforcement log, as text (default) or one
+ * self-contained HTML page (`--format html`, optionally `--to <file>`). Covers the latest session unless
+ * `--session <id>` or `--all` says otherwise.
+ */
+export async function enforcement(c) {
+    const [, sub] = c.args.positionals;
+    if (sub !== "report")
+        throw new CliError("usage: invariant enforcement report [--session <id>|--all] [--format text|html] [--to <file>]");
+    const format = c.args.values.format ?? "text";
+    if (format !== "text" && format !== "html")
+        throw new CliError("--format must be text or html");
+    const events = readEvents(c.cwd);
+    const last = events.at(-1);
+    const session = c.args.values.all ? "all" : (c.args.values.session ?? last?.session ?? "none");
+    const chosen = c.args.values.all ? events : events.filter((e) => e.session === session);
+    const summary = summarize(session, chosen);
+    const out = format === "html" ? renderHtml(summary) : renderText(summary);
+    const to = c.args.values.to;
+    if (to) {
+        const file = path.resolve(c.cwd, to);
+        mkdirSync(path.dirname(file), { recursive: true });
+        writeFileSync(file, out);
+        c.io.stdout(`wrote ${path.relative(c.cwd, file) || to}\n`);
+    }
+    else
+        c.io.stdout(out);
+    return 0;
+}
+//# sourceMappingURL=commands-enforcement.js.map

package/dist/cli/commands-governance.js

@@ -0,0 +1,179 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { resolveFactPath } from "../contract/index.js";
+import { addDecision, claimsHash, DECISIONS_FILE, parseDecisions, serializeDecisions } from "../governance/index.js";
+import { buildReviewQueue } from "../reconciliation/index.js";
+import { json, outputDir, print } from "./commands.js";
+import { loadConfig } from "./config.js";
+import { CliError } from "./errors.js";
+import { shortValue, table } from "./format.js";
+import { loadCompiled } from "./store.js";
+import { CLI_NAME } from "./version.js";
+function items(contract) {
+    const { integrity: _i, ...draft } = contract;
+    return buildReviewQueue(draft);
+}
+function find(queue, id) {
+    const exact = queue.filter((i) => i.id === id);
+    const hits = exact.length > 0 ? exact : queue.filter((i) => i.id.startsWith(id));
+    if (hits.length === 0)
+        throw new CliError(`no open review item "${id}". List them with \`${CLI_NAME} review list\`; decided items disappear after \`${CLI_NAME} compile\`.`, 1);
+    if (hits.length > 1)
+        throw new CliError(`"${id}" matches ${hits.length} items; use more characters`, 1);
+    return hits[0];
+}
+export async function review(c) {
+    const [, sub, id] = c.args.positionals;
+    const { contract, evidence } = loadCompiled(await outputDir(c));
+    const queue = items(contract);
+    if (sub === "list") {
+        const kind = c.args.values.kind;
+        const rows = queue.filter((i) => !kind || i.kind === kind);
+        if (c.args.values.json)
+            json(c, rows);
+        else
+            print(c, rows.length === 0
+                ? "nothing to review"
+                : table(["id", "priority", "kind", "subject", "path", "confidence", "reason"], rows.map((i) => [
+                    i.id,
+                    i.priority,
+                    i.kind,
+                    i.subject,
+                    i.path ?? "",
+                    i.confidence ?? "",
+                    shortValue(i.reason, 60)
+                ])));
+        return 0;
+    }
+    if (sub === "show") {
+        if (!id)
+            throw new CliError("usage: invariant review show <id>");
+        const item = find(queue, id);
+        const evidenceById = new Map(evidence.evidence.map((e) => [e.id, e]));
+        const where = item.evidenceIds
+            .map((e) => evidenceById.get(e))
+            .map((e) => e?.location.type === "file"
+            ? `${e.location.path}${e.location.line ? `:${e.location.line}` : ""}`
+            : (e?.sourceRef ?? ""));
+        if (c.args.values.json) {
+            json(c, { ...item, evidence: where });
+            return 0;
+        }
+        print(c, `${item.id}  ${item.kind}  ${item.priority}`);
+        print(c, `subject: ${item.subject}${item.path ? `  path: ${item.path}` : ""}`);
+        if (item.rule)
+            print(c, `rule: ${item.rule}  confidence: ${item.confidence}`);
+        print(c, `reason: ${item.reason}`);
+        print(c, `evidence: ${[...new Set(where)].join(", ") || "none"}`);
+        if (item.conflictId) {
+            const conflict = contract.conflicts.find((x) => x.id === item.conflictId);
+            print(c, "claims:");
+            for (const cl of conflict?.claims ?? [])
+                print(c, `  ${cl.sourceId} (${cl.status}): ${cl.value === undefined ? "(absent)" : JSON.stringify(cl.value)}`);
+        }
+        return 0;
+    }
+    const factActions = ["approve", "reject"];
+    const conflictActions = ["resolve", "accept", "dismiss"];
+    if (!sub || ![...factActions, ...conflictActions].includes(sub) || !id)
+        throw new CliError("usage: invariant review <list|show <id>|approve <id>|reject <id>|resolve <id>|accept <id>|dismiss <id>> --as <name> [--role r] [--reference ref] [--note n] [--source id]");
+    const loaded = await loadConfig({
+        cwd: c.cwd,
+        file: c.args.values.config,
+        trustConfig: c.args.values["trust-config"] === true
+    });
+    const by = c.args.values.as ?? c.io.env?.INVARIANT_USER;
+    if (!by || by.trim() === "")
+        throw new CliError("say who is deciding: --as <name> (or set INVARIANT_USER). Names are recorded, not authenticated.");
+    const approvers = loaded?.config.governance?.approvers;
+    if (approvers && approvers.length > 0 && !approvers.includes(by))
+        throw new CliError(`"${by}" is not listed in governance.approvers`);
+    const item = find(queue, id);
+    const at = c.io.clock();
+    const note = c.args.values.note;
+    let decision;
+    if (conflictActions.includes(sub)) {
+        if (item.kind !== "conflict" || !item.conflictId)
+            throw new CliError(`${sub} applies to conflicts; ${item.id} is a fact (use approve${item.kind === "inferred-fact" ? " or reject" : ""})`);
+        const conflict = contract.conflicts.find((x) => x.id === item.conflictId);
+        if (!conflict)
+            throw new CliError("the conflict is no longer in the contract", 1);
+        const source = c.args.values.source;
+        if (source && !conflict.claims.some((cl) => cl.sourceId === source))
+            throw new CliError(`--source must be one of: ${conflict.claims.map((cl) => cl.sourceId).join(", ")}`);
+        decision = {
+            kind: "conflict",
+            action: sub,
+            id: conflict.id,
+            claimsHash: claimsHash(conflict),
+            ...(source ? { chosenSourceId: source } : {}),
+            by,
+            at,
+            ...(note ? { note } : {})
+        };
+    }
+    else {
+        if (item.kind === "conflict" || !item.path)
+            throw new CliError(`${sub} applies to facts; ${item.id} is a conflict (use resolve, accept or dismiss)`);
+        if (item.kind === "pattern-fact" && sub === "reject")
+            throw new CliError(`${item.id} is part of a pattern you wrote; reject does not apply. Approve it, or edit or remove the definition.`);
+        const entity = [
+            ...contract.components,
+            ...contract.tokens,
+            ...contract.guidelines,
+            ...contract.patterns,
+            ...contract.constraints
+        ].find((e) => e.id === item.subject);
+        const value = entity ? resolveFactPath(entity, item.path) : { found: false };
+        if (!value.found)
+            throw new CliError(`cannot read ${item.subject} ${item.path} from the contract`, 1);
+        decision = {
+            kind: "fact",
+            action: sub,
+            subject: item.subject,
+            path: item.path,
+            value: value.value,
+            ...(c.args.values.role ? { role: c.args.values.role } : {}),
+            ...(c.args.values.reference ? { reference: c.args.values.reference } : {}),
+            by,
+            at,
+            ...(note ? { note } : {})
+        };
+    }
+    const file = path.resolve(c.cwd, loaded?.config.governance?.decisionsFile ?? DECISIONS_FILE);
+    let current;
+    if (existsSync(file)) {
+        const parsed = parseDecisions(readFileSync(file, "utf8"));
+        if (!parsed.ok)
+            throw new CliError(parsed.message);
+        current = parsed.value;
+    }
+    writeFileSync(file, serializeDecisions(addDecision(current, decision)), "utf8");
+    print(c, `recorded: ${sub} ${item.subject}${item.path ? ` ${item.path}` : ""} by ${by}`);
+    print(c, `Run \`${CLI_NAME} compile\` to apply it, and commit ${path.relative(c.cwd, file)}.`);
+    return 0;
+}
+export async function policy(c) {
+    if (c.args.positionals[1] !== "list")
+        throw new CliError("usage: invariant policy list");
+    const { contract } = loadCompiled(await outputDir(c));
+    if (c.args.values.json) {
+        json(c, contract.policies);
+        return 0;
+    }
+    print(c, contract.policies.length === 0
+        ? `no approved policies. Write them in invariant.policies.json and run \`${CLI_NAME} compile\`.`
+        : table(["id", "severity", "enforcement", "rule", "approved by", "approved at"], contract.policies.map((p) => {
+            const rule = contract.constraints.find((k) => k.id === p.basedOn[0])?.extensions?.invariant?.rule?.kind ?? "";
+            return [
+                p.id,
+                p.severity,
+                p.enforcement,
+                rule,
+                p.approval.approvedBy,
+                p.approval.approvedAt.slice(0, 10)
+            ];
+        })));
+    return 0;
+}
+//# sourceMappingURL=commands-governance.js.map