@invariant-ui/cli 0.0.0-stage → 0.1.0

package/dist/cli/commands-hook.js

@@ -0,0 +1,269 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { globToRegExp, matchesAny } from "../compiler-core/index.js";
+import { DesignSystem } from "../contract-query/index.js";
+import { enforcementCard, passCard, validateCode } from "../validation/index.js";
+import { z } from "zod";
+import { applyBaseline, BASELINE_FILE, readBaseline } from "./baseline.js";
+import { EXTENSIONS, frameworkFor } from "./commands-validate.js";
+import { loadConfig, outputDirectory } from "./config.js";
+import { appendEvent } from "./enforcement-log.js";
+import { CliError } from "./errors.js";
+import { loadCompiled } from "./store.js";
+/**
+ * `invariant hook`: the agent-enforcement entry point. A coding agent (Claude Code today) runs this as a
+ * `PreToolUse`/`PostToolUse` hook on Write and Edit, passing the hook payload on stdin. The command validates
+ * the file the agent is writing against the compiled contract and answers in the agent's hook format:
+ *
+ * - `PreToolUse`, posture `gate-errors`: error-severity findings (after the baseline and rule overrides) deny
+ *   the write, with the findings as the reason the agent must fix.
+ * - `PostToolUse`: findings are reported next to the tool result so the agent can fix them in a follow-up edit,
+ *   and a clean pass is confirmed to the person watching.
+ *
+ * The hook fails open: any problem (no config, no contract, malformed payload, oversized input) is noted on
+ * stderr and the write proceeds. Warnings never block a write.
+ */
+/** Claude Code hook payloads carry the whole file; the MCP line limit is a reasonable ceiling here too. */
+const MAX_PAYLOAD_CHARS = 2_000_000;
+export const POSTURES = ["gate-errors", "warn", "off"];
+export const DEFAULT_POSTURE = "gate-errors";
+const payloadSchema = z.object({
+    hook_event_name: z.string(),
+    tool_name: z.string(),
+    cwd: z.string().optional(),
+    session_id: z.string().optional(),
+    tool_input: z.object({
+        /** Claude Code always expands it to an absolute path before hooks run. */
+        file_path: z.string().min(1),
+        content: z.string().optional(),
+        old_string: z.string().optional(),
+        new_string: z.string().optional(),
+        replace_all: z.boolean().optional()
+    })
+});
+/**
+ * Cursor's `afterFileEdit` payload (cursor.com/docs/hooks): the edit has already landed, so it is treated as a
+ * `PostToolUse` on the file. The fields are from the docs; the answer shape in {@link cursorAnswer} is not yet
+ * verified against a live Cursor.
+ */
+const cursorPayloadSchema = z.object({
+    hook_event_name: z.string(),
+    file_path: z.string().min(1),
+    workspace_roots: z.array(z.string()).optional(),
+    conversation_id: z.string().optional()
+});
+const CLIENTS = ["claude-code", "cursor"];
+function cursorPayload(raw) {
+    const parsed = cursorPayloadSchema.safeParse(raw);
+    if (!parsed.success || parsed.data.hook_event_name !== "afterFileEdit")
+        return undefined;
+    const root = parsed.data.workspace_roots?.find((r) => parsed.data.file_path.startsWith(r));
+    return {
+        hook_event_name: "PostToolUse",
+        tool_name: "Edit",
+        ...((root ?? parsed.data.workspace_roots?.[0]) ? { cwd: root ?? parsed.data.workspace_roots?.[0] } : {}),
+        ...(parsed.data.conversation_id ? { session_id: parsed.data.conversation_id } : {}),
+        tool_input: { file_path: parsed.data.file_path }
+    };
+}
+/** Cursor reads `agent_message` as feedback to the model and `user_message` as text for the person. */
+function cursorAnswer(decision) {
+    if (typeof decision.reason === "string")
+        return { agent_message: decision.reason };
+    if (typeof decision.systemMessage === "string")
+        return { user_message: decision.systemMessage };
+    return {};
+}
+async function readAll(stream, max) {
+    let text = "";
+    for await (const chunk of stream) {
+        text += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+        if (text.length > max)
+            throw new CliError(`the hook payload is larger than ${max.toLocaleString()} characters`);
+    }
+    return text;
+}
+/**
+ * The content the write would produce. `Write` carries it; `Edit` carries only the change, so the current file
+ * is read and the edit applied to reconstruct it. When the edit cannot apply (old text missing or ambiguous),
+ * the agent's own Edit call fails anyway and the hook stays silent; `PostToolUse` reads what landed.
+ */
+function contentFor(event, tool, input, file) {
+    if (event === "PostToolUse") {
+        try {
+            return readFileSync(file, "utf8");
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (tool === "Write")
+        return input.content;
+    if (input.old_string === undefined || input.new_string === undefined)
+        return undefined;
+    let current;
+    try {
+        current = readFileSync(file, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    const parts = current.split(input.old_string);
+    if (parts.length === 1)
+        return undefined;
+    if (parts.length > 2 && input.replace_all !== true)
+        return undefined;
+    return parts.join(input.new_string);
+}
+/** Runs the check and returns the hook's JSON answer, or undefined to stay silent. */
+async function decide(c, payload) {
+    const event = payload.hook_event_name;
+    if (event !== "PreToolUse" && event !== "PostToolUse")
+        return undefined;
+    if (payload.tool_name !== "Write" && payload.tool_name !== "Edit")
+        return undefined;
+    const file = payload.tool_input.file_path;
+    if (!EXTENSIONS.test(file))
+        return undefined;
+    // The project is where the session runs: the agent exports CLAUDE_PROJECT_DIR to hooks, the payload carries
+    // the working directory, and an explicit --cwd wins for manual runs.
+    const root = c.args.values.cwd ? c.cwd : (c.io.env?.CLAUDE_PROJECT_DIR ?? payload.cwd ?? c.cwd);
+    const rel = path.relative(root, file);
+    if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel))
+        return undefined;
+    const loaded = await loadConfig({ cwd: root, trustConfig: false });
+    if (!loaded) {
+        if (c.args.values.quiet !== true)
+            c.io.stderr(`invariant hook: no invariant.config.json in ${root}; the write proceeds unchecked\n`);
+        return undefined;
+    }
+    const ignore = (loaded.config.validation?.ignore ?? []).map((g) => globToRegExp(g));
+    if (matchesAny(rel, ignore))
+        return undefined;
+    const postureArg = c.args.values.posture;
+    if (postureArg && !POSTURES.includes(postureArg))
+        throw new CliError(`--posture must be one of ${POSTURES.join(", ")}`);
+    const posture = (postureArg ?? loaded.config.enforcement?.hooks ?? DEFAULT_POSTURE);
+    if (posture === "off")
+        return undefined;
+    const dir = path.resolve(root, outputDirectory(loaded.config));
+    if (!existsSync(path.join(dir, "invariant.contract.json"))) {
+        if (c.args.values.quiet !== true)
+            c.io.stderr(`invariant hook: no compiled contract in ${path.relative(root, dir) || "."}; run \`invariant compile\`. The write proceeds unchecked.\n`);
+        return undefined;
+    }
+    const { contract, evidence } = loadCompiled(dir);
+    const ds = new DesignSystem(contract, evidence);
+    const content = contentFor(event, payload.tool_name, payload.tool_input, file);
+    if (content === undefined)
+        return undefined;
+    const rules = (loaded.config.validation?.rules ?? {});
+    const result = validateCode(ds, { code: content, filename: rel, framework: frameworkFor(rel) }, { rules });
+    let violations = result.findings.map((f) => ({ ...f, file: rel }));
+    const baselineFile = path.resolve(root, BASELINE_FILE);
+    if (existsSync(baselineFile)) {
+        try {
+            const baseline = readBaseline(baselineFile);
+            if (baseline)
+                violations = applyBaseline(violations, baseline).fresh;
+        }
+        catch (error) {
+            // A broken baseline must not block writes: note it and check without one.
+            c.io.stderr(`invariant hook: ${error.message}\n`);
+        }
+    }
+    const name = contract.metadata.name;
+    const log = (outcome) => {
+        try {
+            appendEvent(root, {
+                time: c.io.clock(),
+                session: payload.session_id ?? "unknown",
+                file: rel,
+                outcome,
+                findings: violations,
+                checked: result.summary.componentsChecked.length
+            });
+        }
+        catch (error) {
+            c.io.stderr(`invariant hook: could not write the enforcement log: ${error.message}\n`);
+        }
+    };
+    const more = (n) => `…and ${n} more (run \`invariant validate ${rel}\`)`;
+    if (event === "PreToolUse") {
+        if (posture === "gate-errors" && violations.some((v) => v.severity === "error")) {
+            log("blocked");
+            return {
+                hookSpecificOutput: {
+                    hookEventName: "PreToolUse",
+                    permissionDecision: "deny",
+                    permissionDecisionReason: enforcementCard({
+                        findings: violations,
+                        contractName: name,
+                        file: rel,
+                        blocked: true,
+                        next: "Fix these, then write the file again.",
+                        more
+                    })
+                }
+            };
+        }
+        return undefined;
+    }
+    log(violations.length > 0 ? "warned" : "passed");
+    if (violations.length > 0)
+        return {
+            decision: "block",
+            reason: enforcementCard({
+                findings: violations,
+                contractName: name,
+                file: rel,
+                next: "Fix these in a follow-up edit.",
+                more
+            })
+        };
+    return {
+        systemMessage: passCard({
+            contractName: name,
+            file: rel,
+            componentsChecked: result.summary.componentsChecked
+        })
+    };
+}
+/** `invariant hook`: check an agent's Write/Edit against the contract and answer in its hook format. */
+export async function hook(c) {
+    const { input } = c.io;
+    if (!input)
+        throw new CliError("`hook` reads the agent's hook payload from standard input");
+    const client = c.args.values.client ?? "claude-code";
+    if (!CLIENTS.includes(client))
+        throw new CliError(`--client must be one of ${CLIENTS.join(", ")}`);
+    let payload;
+    try {
+        const raw = JSON.parse(await readAll(input, MAX_PAYLOAD_CHARS));
+        if (client === "cursor")
+            payload = cursorPayload(raw);
+        else {
+            const parsed = payloadSchema.safeParse(raw);
+            if (parsed.success)
+                payload = parsed.data;
+        }
+        if (!payload)
+            c.io.stderr(`invariant hook: unrecognized payload; staying silent\n`);
+    }
+    catch (error) {
+        // Fail open in every way: the write proceeds and the reason is visible on stderr.
+        c.io.stderr(`invariant hook: ${error.message}\n`);
+    }
+    if (!payload)
+        return 0;
+    try {
+        const decision = await decide(c, payload);
+        if (decision)
+            c.io.stdout(`${JSON.stringify(client === "cursor" ? cursorAnswer(decision) : decision)}\n`);
+    }
+    catch (error) {
+        c.io.stderr(`invariant hook: ${error.message}\n`);
+    }
+    return 0;
+}
+//# sourceMappingURL=commands-hook.js.map

package/dist/cli/commands-patterns.js

@@ -0,0 +1,324 @@
+import { archetypeView, DesignSystem, patternRelationships, patternsView, patternView, search } from "../contract-query/index.js";
+import { json, outputDir, print } from "./commands.js";
+import { CliError } from "./errors.js";
+import { shortValue, table } from "./format.js";
+import { loadCompiled } from "./store.js";
+import { CLI_NAME } from "./version.js";
+const CATEGORIES = [
+    "layout",
+    "navigation",
+    "form",
+    "data-table",
+    "card",
+    "dialog",
+    "workflow",
+    "composition",
+    "interaction",
+    "page",
+    "other"
+];
+const STATUSES = ["approved", "documented", "discovered", "inferred", "mixed", "none"];
+const DIRECTIONS = ["out", "in", "both"];
+const USAGE = `usage: ${CLI_NAME} patterns <list|inspect|resolve|search|relationships> ...
+  patterns list [--category c] [--status s]
+  patterns inspect <name|id> [--evidence]
+  patterns resolve <name|id> [--variation name]
+  patterns search <query>
+  patterns relationships <name|id> [--direction out|in|both] [--depth 1-5]`;
+const rows = (value) => (Array.isArray(value) ? value : []);
+const text = (value) => value === undefined || value === null ? "" : typeof value === "string" ? value : String(value);
+function choice(name, value, allowed) {
+    if (value === undefined)
+        return undefined;
+    if (!allowed.includes(value))
+        throw new CliError(`--${name} must be one of: ${allowed.join(", ")}`);
+    return value;
+}
+function resolve(ds, query) {
+    if (!query)
+        throw new CliError(USAGE);
+    const found = ds.findPattern(query);
+    if (found.match)
+        return found.match;
+    const names = found.candidates.map((p) => p.id).join(", ");
+    throw new CliError(found.candidates.length > 1
+        ? `"${query}" matches several patterns: ${names}. Use the id.`
+        : `no pattern matches "${query}"${names ? `. Did you mean: ${names}?` : ""}`);
+}
+function statusText(status) {
+    const counts = Object.entries((status.counts ?? {}))
+        .map(([k, v]) => `${k} ${text(v)}`)
+        .join(", ");
+    return `${text(status.overall)}${counts ? ` (${counts})` : ""}`;
+}
+function inspect(c, ds, query) {
+    const pattern = resolve(ds, query);
+    const view = patternView(ds, pattern);
+    if (c.args.values.json) {
+        json(c, view);
+        return;
+    }
+    const status = view.status;
+    print(c, `${text(view.name)}  (${text(view.id)})`);
+    print(c, `category: ${text(view.category)}   status: ${statusText(status)}${view.approved ? "" : "   NOT APPROVED"}`);
+    if (view.intent)
+        print(c, `intent: ${text(view.intent)}`);
+    print(c, text(view.description));
+    const scope = view.scope;
+    if (scope) {
+        const paths = scope.paths?.join(", ") ?? "any file";
+        const inherits = scope.inheritsConstraints
+            ? scope.inheritanceActive
+                ? "inherits constraints of what it composes"
+                : "opts in to inheriting constraints (not approved, so off)"
+            : "does not inherit constraints";
+        print(c, `applies to: ${paths}   ${inherits}`);
+    }
+    const parts = rows(view.composition?.parts ?? []);
+    if (parts.length > 0) {
+        print(c, "\ncomposition");
+        print(c, table(["part", "role", "ref", "region", "status"], parts.map((p) => [
+            text(p.name),
+            text(p.role),
+            text(p.ref.name ?? p.ref.id),
+            text(p.region),
+            text(p.fact?.status)
+        ])));
+    }
+    const regions = rows(view.layout?.regions ?? []);
+    if (regions.length > 0) {
+        print(c, "\nlayout regions");
+        print(c, table(["region", "required", "parent", "accepts"], regions.map((r) => [text(r.name), r.required ? "yes" : "", text(r.parent), shortValue(r.accepts, 40)])));
+    }
+    const behavior = view.behavior;
+    if (behavior) {
+        print(c, `\nbehavior (initial state: ${text(behavior.initial)})`);
+        print(c, table(["transition", "from", "to", "trigger", "verifiable by"], rows(behavior.transitions).map((t) => [
+            text(t.id),
+            text(t.from),
+            text(t.to),
+            text(t.trigger),
+            text(t.verifiableBy)
+        ])));
+        const feedback = rows(behavior.states).filter((s) => s.feedback);
+        if (feedback.length > 0)
+            print(c, `required feedback: ${feedback.map((s) => `${text(s.name)}: ${text(s.feedback)}`).join("; ")}`);
+    }
+    const reqs = rows(view.accessibility?.requirements ?? []);
+    if (reqs.length > 0) {
+        print(c, "\naccessibility");
+        for (const r of reqs)
+            print(c, `  ${text(r.id)}: ${text(r.statement)}${r.verifiableBy ? ` [${text(r.verifiableBy)}]` : ""}`);
+    }
+    const constraints = rows(view.constraints);
+    if (constraints.length > 0) {
+        print(c, "\nconstraints");
+        print(c, table(["id", "kind", "details"], constraints.map((k) => [text(k.id), text(k.kind), shortValue(k.details, 60)])));
+    }
+    const relationships = rows(view.relationships);
+    if (relationships.length > 0) {
+        print(c, "\nrelationships");
+        print(c, table(["id", "type", "target", "status"], relationships.map((r) => [
+            text(r.id),
+            text(r.type),
+            text(r.target.name ?? r.target.id),
+            text(r.fact?.status)
+        ])));
+    }
+    const enforced = rows(view.enforcedBy);
+    print(c, enforced.length === 0
+        ? "\nenforced by: no approved policy"
+        : `\nenforced by: ${enforced.map((e) => `${text(e.policy)} (${text(e.enforcement)})`).join(", ")}`);
+    if (c.args.values.evidence) {
+        print(c, "\nevidence");
+        for (const f of rows(view.facts)) {
+            const where = rows(f.evidence)
+                .map((e) => `${text(e.location)} [${text(e.method)}]`)
+                .join("; ");
+            print(c, `  ${text(f.path)}  ${text(f.status)}${f.confidence !== undefined ? ` ${text(f.confidence)}` : ""}  ${where}`);
+        }
+    }
+    for (const note of view.notes ?? [])
+        print(c, `note: ${note}`);
+}
+function tree(parts, related, indent, lines) {
+    for (const p of parts) {
+        const ref = p.ref;
+        lines.push(`${indent}${text(p.name)}  ${text(p.role)}${p.region ? `, region ${text(p.region)}` : ""}  ${text(ref.name ?? ref.id)}${ref.kind === "pattern" ? " (pattern)" : ""}`);
+        nest(p.expanded, indent, lines);
+    }
+    for (const r of related) {
+        const target = r.target;
+        lines.push(`${indent}${text(r.type)}  ${text(target.name ?? target.id)}`);
+        nest(r.expanded, indent, lines);
+    }
+}
+function nest(expanded, indent, lines) {
+    if (!expanded)
+        return;
+    if (expanded.cycle) {
+        lines.push(`${indent}  (already shown above)`);
+        return;
+    }
+    if (expanded.truncated) {
+        lines.push(`${indent}  (not followed further)`);
+        return;
+    }
+    const p = expanded.pattern;
+    lines.push(`${indent}  ${text(p.name)}  [${text(p.status)}${p.approved ? "" : " *"}]`);
+    tree(rows(expanded.parts), rows(expanded.related), `${indent}    `, lines);
+}
+function resolveView(c, ds, query) {
+    const pattern = resolve(ds, query);
+    const result = archetypeView(ds, pattern, { variation: c.args.values.variation });
+    if (!result.ok)
+        throw new CliError(result.message);
+    const view = result.view;
+    if (c.args.values.json) {
+        json(c, view);
+        return;
+    }
+    const status = view.status;
+    print(c, `${text(view.name)}  (${text(view.id)})${view.variation ? `  variation: ${text(view.variation)}` : ""}`);
+    print(c, `category: ${text(view.category)}   status: ${statusText(status)}${view.approved ? "" : "   NOT APPROVED"}`);
+    if (view.intent)
+        print(c, `intent: ${text(view.intent)}`);
+    const regions = rows(view.regions);
+    if (regions.length > 0) {
+        print(c, "\nregions");
+        print(c, table(["region", "required", "parts"], regions.map((r) => [
+            text(r.name),
+            r.required ? "yes" : "",
+            (r.parts ?? []).join(", ")
+        ])));
+    }
+    const lines = [];
+    const root = view.composition;
+    tree(rows(root.parts), rows(root.related), "  ", lines);
+    print(c, `\ncomposition  (* not approved)\n${lines.join("\n")}`);
+    const variations = rows(view.variations);
+    if (variations.length > 0) {
+        print(c, "\nvariations");
+        print(c, table(["name", "when", "changes", "adds"], variations.map((v) => [
+            text(v.name),
+            shortValue(v.when, 40),
+            rows(v.roles)
+                .map((x) => `${text(x.part)}: ${text(x.role)}`)
+                .join(", "),
+            rows(v.addedParts)
+                .map((x) => text(x.name))
+                .join(", ")
+        ])));
+    }
+    const states = rows(view.requiredStates);
+    if (states.length > 0) {
+        print(c, "\nrequired interaction states");
+        print(c, table(["pattern", "workflow", "state", "minimum", "enforced"], states.map((s) => [
+            text(s.pattern),
+            text(s.workflow),
+            text(s.state),
+            text(s.minimum),
+            s.enforced ? "yes" : "no"
+        ])));
+    }
+    const constraints = rows(view.constraints);
+    if (constraints.length > 0) {
+        print(c, "\nconstraints");
+        print(c, table(["pattern", "kind", "enforced"], constraints.map((k) => [text(k.pattern), text(k.kind), k.enforced ? "yes" : "no"])));
+    }
+    const responsive = rows(view.responsive);
+    if (responsive.length > 0) {
+        print(c, "\nresponsive");
+        for (const x of responsive)
+            print(c, `  ${text(x.region)}: ${text(x.behavior)} at ${text(x.breakpoint)}`);
+    }
+    const prohibited = view.prohibited;
+    const parts = rows(prohibited.parts);
+    if (parts.length > 0)
+        print(c, `\nprohibited parts: ${parts.map((p) => text(p.name)).join(", ")}`);
+    const pairs = rows(prohibited.patterns);
+    if (pairs.length > 0)
+        print(c, `\nprohibited together: ${pairs.map((p) => `${text(p.pattern)} with ${text(p.with)}${p.composedHere ? " (BOTH COMPOSED HERE)" : ""}`).join("; ")}`);
+    for (const note of view.notes ?? [])
+        print(c, `note: ${note}`);
+}
+function relationships(c, ds, query) {
+    const pattern = resolve(ds, query);
+    const direction = choice("direction", c.args.values.direction, DIRECTIONS);
+    const rawDepth = c.args.values.depth;
+    const depth = rawDepth === undefined ? undefined : Number(rawDepth);
+    if (depth !== undefined && (!Number.isInteger(depth) || depth < 1 || depth > 5))
+        throw new CliError("--depth must be a whole number from 1 to 5");
+    const view = patternRelationships(ds, pattern, { direction, depth });
+    if (c.args.values.json) {
+        json(c, view);
+        return;
+    }
+    const names = new Map(rows(view.nodes).map((n) => [text(n.id), text(n.name) || text(n.id)]));
+    const edges = rows(view.edges);
+    print(c, `${pattern.name}  (${pattern.id})   direction: ${text(view.direction)}, depth: ${text(view.depth)}`);
+    if (edges.length === 0) {
+        print(c, "no relationships in this direction");
+        return;
+    }
+    print(c, table(["from", "type", "to", "status"], edges.map((e) => [
+        names.get(text(e.from)) ?? text(e.from),
+        `${text(e.type)}${e.role ? ` (${text(e.role)})` : ""}`,
+        names.get(text(e.to)) ?? text(e.to),
+        text(e.status)
+    ])));
+    if (view.truncated)
+        print(c, "note: the walk was cut off at 200 nodes");
+}
+export async function patterns(c) {
+    const [, sub, ...rest] = c.args.positionals;
+    if (!sub || !["list", "inspect", "resolve", "search", "relationships"].includes(sub))
+        throw new CliError(USAGE);
+    const { contract, evidence } = loadCompiled(await outputDir(c));
+    const ds = new DesignSystem(contract, evidence);
+    if (sub === "inspect")
+        inspect(c, ds, rest[0]);
+    else if (sub === "resolve")
+        resolveView(c, ds, rest[0]);
+    else if (sub === "relationships")
+        relationships(c, ds, rest[0]);
+    else if (sub === "search") {
+        const query = rest.join(" ").trim();
+        if (!query)
+            throw new CliError(`usage: ${CLI_NAME} patterns search <query>`);
+        const hits = search(ds, query, ["pattern"], 20).hits;
+        if (c.args.values.json)
+            json(c, hits);
+        else
+            print(c, hits.length === 0
+                ? `no pattern matches "${query}"`
+                : table(["id", "name", "score", "matched on"], hits.map((h) => [h.id, h.name, h.score, h.matchedOn.join(", ")])));
+    }
+    else {
+        const category = choice("category", c.args.values.category, CATEGORIES);
+        const status = choice("status", c.args.values.status, STATUSES);
+        const view = patternsView(ds, { category, status, limit: 200 });
+        if (c.args.values.json) {
+            // Unchanged shape: the matching patterns as written in the contract.
+            const ids = new Set(rows(view.patterns).map((p) => text(p.id)));
+            json(c, contract.patterns.filter((p) => ids.has(p.id)));
+        }
+        else if (rows(view.patterns).length === 0)
+            print(c, contract.patterns.length === 0
+                ? "no patterns. Invariant does not infer patterns from code yet, and no source documents one."
+                : `no pattern matches these filters (${contract.patterns.length} in the contract)`);
+        else {
+            print(c, table(["id", "name", "category", "status", "components"], rows(view.patterns).map((p) => [
+                text(p.id),
+                text(p.name),
+                text(p.category),
+                `${text(p.status.overall)}${p.approved ? "" : " *"}`,
+                p.components.length
+            ])));
+            if (rows(view.patterns).some((p) => !p.approved))
+                print(c, "\n* not approved: treat as a proposal");
+        }
+    }
+    return 0;
+}
+//# sourceMappingURL=commands-patterns.js.map