@intentius/chant 0.124.45 → 0.124.46

package/dist/capabilities/matcher.js

@@ -0,0 +1,299 @@
+export class CapabilityError extends Error {
+}
+const glob = (pattern, s) => new RegExp(`^${pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".")}$`, "i").test(s);
+function equal(a, b) {
+    if (b === null)
+        return a === null || a === undefined;
+    if (a === b)
+        return true;
+    if (a === null || a === undefined || typeof a === "object")
+        return false;
+    return String(a) === String(b);
+}
+function present(a) {
+    return a !== undefined && a !== null && a !== false && !(Array.isArray(a) && a.length === 0);
+}
+const reverseHops = (hops) => [...hops].reverse();
+export class CapabilityEngine {
+    constructor(view, rules) {
+        this.view = view;
+        this.rules = new Map();
+        this.sets = new Map();
+        this.relations = new Map();
+        this.busy = new Set();
+        this.out = new Map();
+        this.in = new Map();
+        this.byLabel = new Map();
+        for (const r of rules)
+            this.rules.set(r.name, r);
+        for (const e of view.edges) {
+            this.index(this.out, e.from, e.name, e.to, e.hops);
+            this.index(this.in, e.to, e.name, e.from, reverseHops(e.hops));
+        }
+        for (const n of view.nodes.values()) {
+            if (!this.byLabel.has(n.label))
+                this.byLabel.set(n.label, []);
+            this.byLabel.get(n.label).push(n.id);
+        }
+        for (const r of rules)
+            this.check(r);
+    }
+    index(ix, a, name, b, hops) {
+        let m = ix.get(a);
+        if (!m)
+            ix.set(a, (m = new Map()));
+        let l = m.get(name);
+        if (!l)
+            m.set(name, (l = []));
+        l.push({ to: b, hops });
+    }
+    /** Refuse a rule that names a capability that doesn't exist, or uses one in the wrong shape. */
+    check(r) {
+        const node = (n, alt) => {
+            for (const t of n.tests) {
+                if (t.kind !== "cap")
+                    continue;
+                const target = this.rules.get(t.cap);
+                if (!target)
+                    throw new CapabilityError(`${r.name} (line ${alt.line}): no capability "${t.cap}"`);
+                if (target.vars.length !== 1)
+                    throw new CapabilityError(`${r.name} (line ${alt.line}): "@${t.cap}" is an edge, not a set; follow it with ->${t.cap}`);
+            }
+        };
+        for (const alt of r.alts) {
+            node(alt.head, alt);
+            for (const s of alt.steps) {
+                node(s.node, alt);
+                for (const n of s.names) {
+                    const target = this.rules.get(n.name);
+                    if (target && target.vars.length !== 2) {
+                        throw new CapabilityError(`${r.name} (line ${alt.line}): "${n.name}" is a set, not an edge; test it with [@${n.name}]`);
+                    }
+                }
+            }
+        }
+    }
+    has(name) {
+        return this.rules.has(name);
+    }
+    /** The capabilities the catalog lists: rules that carry a `## meaning`. */
+    publicNames() {
+        return [...this.rules.values()].filter((r) => r.meta.meaning !== undefined).map((r) => r.name);
+    }
+    rule(name) {
+        return this.rules.get(name);
+    }
+    /** Bind positional arguments to a rule's parameters. */
+    bind(name, positional) {
+        const r = this.rules.get(name);
+        if (!r)
+            throw new CapabilityError(`no capability "${name}"`);
+        if (positional.length > r.params.length) {
+            throw new CapabilityError(`${name} takes ${r.params.length === 0 ? "no arguments" : `at most ${r.params.length} (${r.params.map((p) => p.name).join(", ")})`}`);
+        }
+        const args = {};
+        r.params.forEach((p, i) => {
+            const v = positional[i];
+            if (v === undefined && !p.optional)
+                throw new CapabilityError(`${name} needs ${p.name}`);
+            args[p.name] = v;
+        });
+        return args;
+    }
+    key(name, args) {
+        return `${name}(${JSON.stringify(Object.entries(args).filter(([, v]) => v !== undefined).sort())})`;
+    }
+    /** The nodes in a set capability, with evidence. */
+    set(name, args = {}) {
+        const r = this.rules.get(name);
+        if (!r)
+            throw new CapabilityError(`no capability "${name}"`);
+        if (r.vars.length !== 1)
+            throw new CapabilityError(`"${name}" is an edge, not a set`);
+        const key = this.key(name, args);
+        const cached = this.sets.get(key);
+        if (cached)
+            return cached;
+        this.enter(key);
+        const out = new Map();
+        for (const alt of r.alts) {
+            for (const s of this.starts(alt.head)) {
+                this.match(alt, s, args, (env, ev) => {
+                    const x = env[r.vars[0]] ?? s;
+                    if (!out.has(x))
+                        out.set(x, ev);
+                });
+            }
+        }
+        this.busy.delete(key);
+        this.sets.set(key, out);
+        return out;
+    }
+    /** The pairs in an edge capability, with evidence. */
+    relation(name, args = {}) {
+        const r = this.rules.get(name);
+        if (!r)
+            throw new CapabilityError(`no capability "${name}"`);
+        if (r.vars.length !== 2)
+            throw new CapabilityError(`"${name}" is a set, not an edge`);
+        const key = this.key(name, args);
+        const cached = this.relations.get(key);
+        if (cached)
+            return cached;
+        this.enter(key);
+        const rel = { out: new Map(), in: new Map() };
+        for (const alt of r.alts) {
+            for (const s of this.starts(alt.head)) {
+                this.match(alt, s, args, (env, ev, last) => {
+                    const a = env[r.vars[0]] ?? s;
+                    const b = env[r.vars[1]] ?? last;
+                    if (a === b)
+                        return;
+                    let m = rel.out.get(a);
+                    if (!m)
+                        rel.out.set(a, (m = new Map()));
+                    if (m.has(b))
+                        return;
+                    m.set(b, ev);
+                    let back = rel.in.get(b);
+                    if (!back)
+                        rel.in.set(b, (back = new Map()));
+                    back.set(a, ev);
+                });
+            }
+        }
+        this.busy.delete(key);
+        this.relations.set(key, rel);
+        return rel;
+    }
+    enter(key) {
+        if (this.busy.has(key)) {
+            throw new CapabilityError(`capability ${key} refers to itself through ${[...this.busy].join(" -> ")}`);
+        }
+        this.busy.add(key);
+    }
+    starts(head) {
+        if (!head.labels)
+            return [...this.view.nodes.keys()];
+        return head.labels.flatMap((l) => this.byLabel.get(l) ?? []);
+    }
+    resolve(v, args) {
+        return "lit" in v ? v.lit : args[v.param];
+    }
+    test(id, t, args, because) {
+        const result = (() => {
+            if (t.kind === "cap") {
+                const capArgs = this.bind(t.cap, t.args.map((v) => this.resolve(v, args)));
+                const ev = this.set(t.cap, capArgs).get(id);
+                if (ev && !t.negated)
+                    because.push({ capability: t.cap, id, evidence: ev });
+                return !!ev;
+            }
+            const n = this.view.nodes.get(id);
+            const a = n.attrs[t.attr];
+            if (t.op === "present")
+                return present(a);
+            const values = t.values.map((v) => this.resolve(v, args));
+            // A test on a parameter nobody passed is left out, whatever else it names.
+            if (values.some((v) => v === undefined))
+                return !t.negated;
+            const given = values;
+            const each = Array.isArray(a) ? a : [a];
+            switch (t.op) {
+                case "=":
+                case "in":
+                    return each.some((x) => given.some((v) => equal(x, v)));
+                case "!=":
+                    return !each.some((x) => equal(x, given[0]));
+                case "~":
+                    return each.some((x) => typeof x === "string" && given.some((v) => typeof v === "string" && (glob(x, v) || glob(v, x))));
+                default: {
+                    const v = Number(given[0]);
+                    return each.some((x) => {
+                        const nx = Number(x);
+                        if (x === null || x === undefined || Number.isNaN(nx) || Number.isNaN(v))
+                            return false;
+                        return t.op === "<" ? nx < v : t.op === "<=" ? nx <= v : t.op === ">" ? nx > v : nx >= v;
+                    });
+                }
+            }
+        })();
+        return t.negated ? !result : result;
+    }
+    ok(id, s, env, args, because) {
+        if (s.v && env[s.v] !== undefined && env[s.v] !== id)
+            return false;
+        const n = this.view.nodes.get(id);
+        if (!n)
+            return false;
+        if (s.labels && !s.labels.includes(n.label))
+            return false;
+        return s.tests.every((t) => this.test(id, t, args, because));
+    }
+    hop(id, step, args) {
+        const out = [];
+        for (const n of step.names) {
+            if (this.rules.has(n.name)) {
+                const rel = this.relation(n.name, this.bind(n.name, n.args.map((v) => this.resolve(v, args))));
+                const m = (step.dir === "out" ? rel.out : rel.in).get(id);
+                if (m)
+                    for (const [to, ev] of m)
+                        out.push({ to, hops: step.dir === "out" ? ev.hops : reverseHops(ev.hops) });
+            }
+            else {
+                out.push(...((step.dir === "out" ? this.out : this.in).get(id)?.get(n.name) ?? []));
+            }
+        }
+        return out;
+    }
+    /** Every node within the step's depth range, by its shortest walk. */
+    walk(id, step, args) {
+        const res = [];
+        const seen = new Set([id]);
+        let frontier = [{ to: id, hops: [] }];
+        if (step.min === 0)
+            res.push(frontier[0]);
+        for (let d = 1; d <= step.max && frontier.length > 0; d++) {
+            const next = [];
+            for (const f of frontier) {
+                for (const h of this.hop(f.to, step, args)) {
+                    if (step.max > 1) {
+                        if (seen.has(h.to))
+                            continue;
+                        seen.add(h.to);
+                    }
+                    const p = { to: h.to, hops: [...f.hops, ...h.hops] };
+                    next.push(p);
+                    if (d >= step.min)
+                        res.push(p);
+                }
+            }
+            frontier = next;
+        }
+        return res;
+    }
+    match(alt, start, args, emit) {
+        const because0 = [];
+        if (!this.ok(start, alt.head, {}, args, because0))
+            return;
+        const env0 = alt.head.v ? { [alt.head.v]: start } : {};
+        const go = (k, at, env, hops, because) => {
+            if (k === alt.steps.length)
+                return emit(env, { hops, because }, at);
+            const st = alt.steps[k];
+            if (st.negated) {
+                const blocked = this.walk(at, st, args).some((w) => this.ok(w.to, st.node, env, args, []));
+                if (!blocked)
+                    go(k + 1, at, env, hops, because);
+                return;
+            }
+            for (const w of this.walk(at, st, args)) {
+                const b = [];
+                if (!this.ok(w.to, st.node, env, args, b))
+                    continue;
+                go(k + 1, w.to, st.node.v ? { ...env, [st.node.v]: w.to } : env, [...hops, ...w.hops], [...because, ...b]);
+            }
+        };
+        go(0, start, env0, [], because0);
+    }
+}

package/dist/capabilities/view.d.ts

@@ -0,0 +1,207 @@
+/**
+ * The lexicon-neutral view capability rules read (#4375, ruled on #4361).
+ *
+ * chant's graph IR can't serve as a rule surface as it stands: an IAM
+ * statement or an inline security-group rule is a property tree inside one
+ * node, a Terraform policy is HCL text in a string, Terraform has link
+ * resources where CloudFormation has a direct reference, and every Terraform
+ * resource is `Terraform::Resource`. So rules read this view instead:
+ *
+ * - labels (`Instance`, `Role`, `SecurityGroup`) from each lexicon's kind
+ *   mapping, and edge names (`subnet`, `sg`) from the IR edge's `viaAttr`;
+ * - a node per policy statement and per inline block (an ingress rule, an
+ *   inline route), joined to its holder by a named edge;
+ * - one edge per link resource (a Terraform policy attachment);
+ * - an edge for an ARN string that names a declared role or bucket.
+ *
+ * The mapping is data, shipped by each lexicon (`CapabilityMapping`). The
+ * adapter below is the code that reads it. What a lexicon can't say as data
+ * (reading a Terraform `jsonencode(...)` policy) it supplies as a hook.
+ */
+import type { GraphIR } from "../graph-ir.js";
+/** A path into a node's attributes: `A.B` follows objects, `A[]` spreads a list. */
+export type AttrPath = string;
+/** Where a neutral attribute is read from: one path, the first present of several, or every value of several. */
+export type AttrSource = AttrPath | AttrPath[] | {
+    all: AttrPath[];
+} | {
+    const: unknown;
+};
+/** A label for a kind, optionally only when the node's attributes match. */
+export type LabelSpec = string | {
+    label: string;
+    when?: Record<string, unknown>;
+    style?: string;
+    set?: Record<string, unknown>;
+};
+/** An inline block exploded into nodes of its own. */
+export interface BlockSpec {
+    /** The attribute holding the block or list of blocks. */
+    attr: AttrPath;
+    label: string;
+    /** The edge from the holder to the block; a leading `-` points it from the block to the holder. */
+    edge: string;
+    attrs?: Record<string, AttrSource>;
+    /** Attributes of the block that reference other nodes, and the edge name each makes from the block. */
+    refs?: Record<string, string>;
+    /** Only blocks whose attributes match. */
+    when?: Record<string, unknown>;
+    /** Recorded as the block node's `style` attribute. */
+    style?: string;
+}
+/** A link resource turned into one edge between the two nodes it links. */
+export interface LinkSpec {
+    /** The view edge (from the link node) whose target is the new edge's source. */
+    from: string;
+    /** The view edge (from the link node) whose target is the new edge's target. */
+    to: string;
+    edge: string;
+}
+/** Why a lexicon can't supply a capability. */
+export interface Unsupported {
+    code: string;
+    message: string;
+}
+/**
+ * A lexicon's mapping onto the view, as data (`<lexicon>/src/capabilities/mapping.json`).
+ * Every field is optional, so a mapping can extend another.
+ */
+export interface CapabilityMapping {
+    lexicon: string;
+    /** How a node's type is read: its IR kind, or its Terraform resource type. */
+    types?: "kind" | "terraform";
+    /** The attribute holding the block body, when it isn't the attributes themselves. */
+    body?: string;
+    /** How references inside attribute values are spelled. */
+    refs?: "cloudformation" | "terraform";
+    labels?: Record<string, LabelSpec>;
+    /**
+     * Per label: IR `viaAttr` -> view edge name. A leading `-` reverses the
+     * edge. Where one attribute references several kinds (a launch template's
+     * `LaunchTemplateData`), the name can be given per target label.
+     */
+    edges?: Record<string, Record<string, string | Record<string, string>>>;
+    /** Per label: neutral attribute -> where it is read from. */
+    attrs?: Record<string, Record<string, AttrSource>>;
+    blocks?: Record<string, BlockSpec[]>;
+    links?: Record<string, LinkSpec>;
+    /** Per label: attribute path of a policy document -> its kind (`permission`, `trust`, `resource`). */
+    documents?: Record<string, Record<AttrPath, string>>;
+    /** Where tags are read from, and which tag keys give a data store its classification. */
+    tags?: AttrPath[];
+    classificationTags?: string[];
+    /** Capabilities this lexicon can't supply, and why. */
+    unsupported?: Record<string, Unsupported>;
+}
+/** What a lexicon supplies as code, for what its mapping can't say as data. */
+export interface CapabilityAdapter {
+    /**
+     * Read a policy document held in an attribute. Return the document as a
+     * JSON object; a value position holding an expression comes back as a
+     * string with the expression in `${...}`. Undefined when it can't be read.
+     */
+    readDocument?(value: unknown): unknown;
+}
+/** One lexicon's contribution: its mapping (data) and its adapter (code). */
+export interface CapabilityPack {
+    mapping: CapabilityMapping;
+    adapter?: CapabilityAdapter;
+}
+/**
+ * One edge of the IR a view edge stands for, in the IR's own direction:
+ * `from` holds the reference, `to` is what it names. #4359's `PathHop`, with
+ * the view edge's name.
+ */
+export interface ViewHop {
+    from: string;
+    fromAttr?: string;
+    to: string;
+    toAttr?: string;
+    edge: string;
+}
+export interface ViewNode {
+    id: string;
+    label: string;
+    /** The IR node this view node is, or sits inside (a statement's holder). */
+    irId: string;
+    lexicon: string;
+    attrs: Record<string, unknown>;
+    /** What the node was read from: the resource's attributes (its block body), or the inline block. */
+    body?: Record<string, unknown>;
+}
+export interface ViewEdge {
+    from: string;
+    to: string;
+    name: string;
+    /** The IR hops this edge stands for, in walk order from `from`. */
+    hops: ViewHop[];
+}
+export interface View {
+    nodes: Map<string, ViewNode>;
+    edges: ViewEdge[];
+    /** Lexicons whose nodes the view read through a mapping. */
+    lexicons: Set<string>;
+    /**
+     * ARN strings that name a role, bucket or table by name, where this view
+     * declares nothing of that name (#4378). A workspace resolves them over
+     * every member's view: the thing may be declared in another member.
+     */
+    unresolved?: UnresolvedArn[];
+}
+/** An ARN a view could not resolve, kept so a composed view can (#4378). */
+export interface UnresolvedArn {
+    /** The view node holding the reference: a statement or an inline block. */
+    from: string;
+    fromAttr: string;
+    /** The view edge it makes once resolved (`resource`, `principal`, or a block's ref edge). */
+    edge: string;
+    value: string;
+}
+/**
+ * Merge mappings for the same lexicon: objects merge key by key at every
+ * depth, lists concatenate, and anything else in a later mapping wins.
+ */
+export declare function mergeMappings(...ms: CapabilityMapping[]): CapabilityMapping;
+/** The bare name a row prints: no stack qualification, no root directory. */
+export declare function displayName(id: string): string;
+/**
+ * Build the view of an IR through the packs given. Nodes of a kind no
+ * mapping labels are left out, as are edges no mapping names.
+ */
+export declare function buildView(ir: GraphIR, packs: CapabilityPack[]): View;
+/** The version of the serialized view a member's `chant graph --capability-view` prints (#4378). */
+export declare const VIEW_DOCUMENT_VERSION = 1;
+/**
+ * The view as a member's `chant graph --format ir --capability-view` prints
+ * it (#4378): built by the member's own chant, through the mappings and
+ * adapters of the lexicons that member loads, so a workspace's rules read
+ * every member as the member's own toolchain maps it. Node bodies are left
+ * out: rules read labels, attributes and edges only.
+ */
+export interface ViewDocument {
+    version: number;
+    lexicons: string[];
+    nodes: {
+        id: string;
+        label: string;
+        irId: string;
+        lexicon: string;
+        attrs: Record<string, unknown>;
+    }[];
+    edges: ViewEdge[];
+    unresolved: UnresolvedArn[];
+}
+export declare function serializeView(view: View): ViewDocument;
+/** Whether a member printed a view this chant reads; anything else is treated as no view. */
+export declare function isViewDocument(v: unknown): v is ViewDocument;
+/** A view document with every id it holds given `prefix` (`<member>/`), as `workspace graph` composes ids. */
+export declare function prefixView(doc: ViewDocument, prefix: string): ViewDocument;
+/**
+ * Compose member views into one (#4378), the matcher's input over a
+ * workspace. Each member's view was mapped by its own chant; the one thing
+ * left to do here is resolve the ARNs a member couldn't, by name over every
+ * member's nodes. Where several members declare the name, the last one in
+ * member order wins, as within one view.
+ */
+export declare function composeViews(docs: ViewDocument[]): View;
+//# sourceMappingURL=view.d.ts.map

package/dist/capabilities/view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view.d.ts","sourceRoot":"","sources":["../../src/capabilities/view.ts"],"names":[],"mappings":"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"}