@intentius/chant 0.124.45 → 0.124.46

package/dist/cli/handlers/graph.js

@@ -1,14 +1,14 @@
-import { dirname, resolve } from "node:path";
+import { isAbsolute, relative, resolve } from "node:path";
 import { discoverOps } from "../../op/discover.js";
 import { discover } from "../../discovery/index.js";
-import { partitionByLexicon, computeStackGraph, build, mergeBuildRootEntities } from "../../build.js";
-import { applyLexiconGraphEdges, applyLexiconOutputs, buildGraphIr, buildLiveGraphIr, collectUnobserved, overlayGraphs, sourceOverlayGraphs, GRAPH_IR_VERSION } from "../../graph-ir.js";
+import { partitionByLexicon, computeStackGraph, build } from "../../build.js";
+import { applyLexiconOutputs, buildGraphIr, buildLiveGraphIr, collectUnobserved, overlayGraphs, sourceOverlayGraphs, GRAPH_IR_VERSION } from "../../graph-ir.js";
 import { behaviourOverlay } from "../../behaviour-overlay.js";
 import { applyBehaviourOverlay, behaviourRequestFromIr } from "../../behaviour-graph.js";
 import { buildDeclaredPerStack } from "../../graph-declared.js";
 import { mergeProjectOps } from "../../graph-ops.js";
 import { reconstructEdges, mergeCatalogs, containmentGroups } from "../../graph-refs.js";
-import { observeResources } from "../../lifecycle/observe.js";
+import { carryAnnotations, observeResources } from "../../lifecycle/observe.js";
 import { withLiveReadSession } from "../../live-read-session.js";
 import { replaySnapshots, hasSnapshot } from "../../lifecycle/replay.js";
 import { loadChantConfig, environmentNames, matchesDeclaredEnvironment, loadChantConfigUpward } from "../../config.js";
@@ -21,6 +21,8 @@ import { getLayoutEngine, toLayoutInput } from "../../graph-layout.js";
 import { lintCommand } from "../commands/lint.js";
 import { reportUninstalledDependencies } from "../dependencies.js";
 import { loadPlugins, resolveProjectLexicons, collectBuildRootContributors } from "../plugins.js";
+// One copy for graph and search (#4365): the build-root join and the lexicon edges.
+import { declaredBuildRootContributors as graphBuildRootContributors, mergeDeclaredBuildRoots as mergeGraphBuildRoots, withLexiconEdges, } from "./declared-graph.js";
 import { isNoLexiconDetected } from "../../detectLexicon.js";
 import { readFileSync } from "node:fs";
 import { formatError, formatWarning, formatBold } from "../format.js";
@@ -71,59 +73,6 @@ async function graphBuildParams(ctx, projectPath) {
     }
     return resolution.provenance;
 }
-/**
- * The build-root contributors this invocation's project configures (#1626) —
- * the same closures `chant build` and the lifecycle handlers hand to
- * `BuildOptions.buildRoots`, bound here for the graph command's
- * discover-based paths, which never run `build()` and so never ran the hook:
- * a `k8s.kustomize.roots` estate graphed only its typed source while its
- * built (and deployed) output carried the rendered manifests too.
- *
- * `graph` is not `requiresPlugins` (Op/source-graph modes must work without a
- * lexicon), so plugins are loaded here when `ctx.plugins` is empty, mirroring
- * `runGraphLive`. Rooted at the config's own directory, like
- * `cli/commands/build.ts` — a relative kustomize root resolves against where
- * it was declared, not against a sourceDir-scoped graph path. A project that
- * fails to load plugins degrades to no contributors with a warning rather
- * than failing modes that never needed plugins at all.
- */
-async function graphBuildRootContributors(ctx, projectPath) {
-    const { config, configPath } = await loadChantConfigUpward(projectPath).catch(() => ({ config: {}, configPath: undefined }));
-    let plugins = ctx.plugins;
-    if (plugins.length === 0) {
-        try {
-            plugins = await loadPlugins(await resolveProjectLexicons(projectPath));
-        }
-        catch (err) {
-            console.error(formatWarning({
-                message: `could not load the project's lexicons — build-root entities (kustomize roots) will be missing from the graph (${err instanceof Error ? err.message : String(err)})`,
-            }));
-            return [];
-        }
-    }
-    return collectBuildRootContributors(plugins, config, configPath ? dirname(configPath) : projectPath);
-}
-/**
- * Merge build-root contributions into a discovered entity set — the exact
- * merge `build()` performs (one implementation: `mergeBuildRootEntities`,
- * ../../build.ts), surfaced in the graph command's error style. Returns false
- * when a contributor failed or a name collided; the caller stops, matching
- * how the discover-based paths treat discovery errors — a graph missing the
- * entities the build would refuse over must not be emitted as if complete.
- */
-async function mergeGraphBuildRoots(entities, contributors) {
-    if (contributors.length === 0)
-        return true;
-    const merged = await mergeBuildRootEntities(entities, contributors);
-    for (const w of merged.warnings)
-        console.error(formatWarning({ message: w }));
-    if (merged.errors.length > 0) {
-        for (const message of merged.errors)
-            console.error(formatError({ message }));
-        return false;
-    }
-    return true;
-}
 /** #1675 — join git-root ops into a discovered entity map; op-discovery
  * errors are warnings here (the lint gate never saw those files). */
 async function mergeGraphOps(entities, sourceFiles, projectPath) {
@@ -165,6 +114,15 @@ async function runGraphCommand(ctx) {
         }));
         return 1;
     }
+    // The capability view (#4378) is built from the declared entity graph's IR,
+    // the read `chant workspace graph --capability-view` asks each member for.
+    if (ctx.args.capabilityView && (ctx.args.format !== "ir" || ctx.args.components || ctx.args.live || ctx.args.at)) {
+        console.error(formatError({
+            message: "--capability-view adds the capability view to the declared graph's IR, so it needs --format ir and takes no --components, --live or --at",
+            hint: "chant graph --format ir --detail 3 --capability-view",
+        }));
+        return 1;
+    }
     // `--at` graphs a recorded observation instead of reading the estate (#1279).
     // Two different observations with no rule for which wins, so not both.
     if (ctx.args.at && ctx.args.live) {
@@ -300,6 +258,8 @@ async function runGraphLive(ctx, format) {
         console.error(formatWarning({ message: endpointResult.notice }));
     let ir;
     let observations;
+    // Facts about absent entities (#4372), carried onto the overlay's nodes.
+    let annotations;
     // A replay is a graph of what was recorded, so it must not reach the provider
     // at all — not for observation and not for enrichment. Anything that quietly
     // called out would make `--at` a live read with an older label on it.
@@ -329,6 +289,7 @@ async function runGraphLive(ctx, format) {
                 ...(args.namespace ? { namespace: args.namespace } : {}),
             });
             observations = observeResult.observations;
+            annotations = observeResult.annotations;
             const { errors, warnings, notes = [] } = observeResult;
             for (const e of errors)
                 console.error(formatWarning({ message: e }));
@@ -443,6 +404,10 @@ async function runGraphLive(ctx, format) {
                         : sourceOverlayGraphs(declaredIr, ir, overlayOpts);
             }
         }
+        // What a read learned about an entity it found absent (#4372), on the
+        // declared node beside the overlay's `_status`. A planned create keeps its
+        // pending paint and carries the plan's attributes.
+        ir = { ...ir, nodes: carryAnnotations(ir.nodes, annotations) };
     }
     // Behaviour overlay (#2377, epic #2355): carry a prediction on the graph.
     // After the drift overlay so it lands on the final node set beside `_status`,
@@ -544,6 +509,55 @@ function refuseLintGate(lint, projectPath) {
         message: "Refusing to emit graph: source has lint errors. Run `chant lint` and fix them first.",
     }));
 }
+/** The project's `graph.lint`: `"report"` only when it says so (#919). */
+async function graphLintMode(projectPath) {
+    const { config } = await loadChantConfigUpward(projectPath).catch(() => ({ config: {} }));
+    return config.graph?.lint === "report" ? "report" : "gate";
+}
+export function graphLintReport(lint, projectPath) {
+    const rel = (file) => {
+        if (!isAbsolute(file))
+            return file;
+        const r = relative(projectPath, file);
+        return r.startsWith("..") ? file : r;
+    };
+    const findings = (lint.diagnostics ?? []).map((d) => ({
+        ruleId: d.ruleId,
+        severity: d.severity,
+        message: d.message,
+        file: rel(d.file),
+        line: d.line,
+        column: d.column,
+        ...(d.entity ? { entity: d.entity } : {}),
+    }));
+    return {
+        errors: findings.filter((f) => f.severity === "error").length,
+        warnings: findings.filter((f) => f.severity === "warning").length,
+        findings,
+    };
+}
+/**
+ * The lint gate for the entity graph. Returns false when the graph must not be
+ * emitted, having printed why. A `graph.lint: "report"` project passes with
+ * lint errors and says so on stderr, unless an error is an uninstalled
+ * dependency: then there is no source to read, and it refuses as the gate does.
+ */
+function passLintGate(lint, projectPath, mode) {
+    if (lint.success)
+        return true;
+    if (mode === "gate") {
+        refuseLintGate(lint, projectPath);
+        return false;
+    }
+    const errors = (lint.diagnostics ?? []).filter((d) => d.severity === "error").map((d) => d.message);
+    if (reportUninstalledDependencies(errors, projectPath))
+        return false;
+    const n = errors.length;
+    console.error(formatWarning({
+        message: `Emitting the graph with ${n} lint error${n === 1 ? "" : "s"}: graph.lint is "report", so every finding is on the IR's meta.lint. Run \`chant lint\` to see them.`,
+    }));
+    return true;
+}
 /**
  * `chant graph --components --format ir|mermaid|dot|layout` — the component DAG
  * projected into the renderable IR (nodes = components, `groups.byWave` = the
@@ -673,7 +687,9 @@ async function buildPipelineProjection(projectPath, lexicon, sandbox) {
  * `--node-sizes` so spacing fits real node footprints, and defaults to the dagre
  * engine (no native dependency); `--layout-engine graphviz` opts into `dot`.
  * Lint-gated: the IR represents valid infra, so we refuse to emit for source that
- * does not pass lint. Non-zero on discovery errors or a layout-engine failure.
+ * does not pass lint, unless the project's config sets `graph.lint: "report"`
+ * (#919): then the graph is emitted and the findings ride on `meta.lint`.
+ * Non-zero on discovery errors or a layout-engine failure.
  */
 /**
  * Add what the lexicons' `graphMeta` hooks report to `ir.meta` (#2559). A
@@ -696,28 +712,6 @@ function withGraphMeta(ir, plugins, entities) {
     }
     return Object.keys(added).length === 0 ? ir : { ...ir, meta: { ...(ir.meta ?? {}), ...added } };
 }
-/**
- * Add the edges the lexicons' `graphEdges` hooks resolve (#3910): CI
- * dependencies written as strings (`needs`, `uses:`, `trigger:`, `include:`,
- * `extends`), which the AttrRef walk in `buildGraphIr` cannot see. A hook that
- * throws costs its own edges and a warning, not the graph.
- */
-function withLexiconEdges(ir, plugins, entities) {
-    const reports = [];
-    for (const p of plugins) {
-        if (!p.graphEdges)
-            continue;
-        try {
-            const report = p.graphEdges(entities);
-            if (report)
-                reports.push(report);
-        }
-        catch (err) {
-            console.error(formatWarning({ message: `the ${p.name} lexicon's graphEdges failed (${err instanceof Error ? err.message : String(err)}); its edges are left out` }));
-        }
-    }
-    return reports.length === 0 ? ir : applyLexiconGraphEdges(ir, reports);
-}
 /**
  * Add the outputs the lexicons' `workspaceOutputs` hooks report (#3931) to
  * the IR's `exports`: a sql table and each of its columns, which `chant
@@ -821,17 +815,17 @@ async function runGraphView(ctx, format) {
     const buildParams = await graphBuildParams(ctx, projectPath);
     if (!buildParams)
         return 1;
-    // Gate: only emit for lint-clean source.
+    // Gate: only emit for lint-clean source, unless the project reads source it
+    // did not author and asks for the findings instead (`graph.lint`, #919).
     const lint = await lintCommand({
         path: ctx.args.path,
         format: "stylish",
         sandbox: ctx.args.sandbox,
         buildParams,
     });
-    if (!lint.success) {
-        refuseLintGate(lint, projectPath);
+    const lintMode = await graphLintMode(projectPath);
+    if (!passLintGate(lint, projectPath, lintMode))
         return 1;
-    }
     const result = await discover(projectPath, { buildParams });
     if (result.errors.length > 0) {
         for (const e of result.errors)
@@ -854,10 +848,10 @@ async function runGraphView(ctx, format) {
     // The declared half of the epic's delta (#2355): this path predicts the
     // file, the live path predicts the account. Same helper, so the two shapes
     // reach the engine by one route and stay comparable.
+    const plugins = ctx.plugins.length > 0
+        ? ctx.plugins
+        : await loadPlugins(await projectLexiconsOrNone(projectPath));
     {
-        const plugins = ctx.plugins.length > 0
-            ? ctx.plugins
-            : await loadPlugins(await projectLexiconsOrNone(projectPath));
         ir = withLexiconEdges(ir, plugins, result.entities);
         ir = withLexiconOutputs(ir, plugins, result.entities);
         const predicted = await predictOntoIr(ir, plugins, ctx.args, {
@@ -894,6 +888,18 @@ async function runGraphView(ctx, format) {
                 console.error(formatWarning({ message: notice }));
         }
     }
+    // Last, so no lens or detail pass can drop it: the findings are about the
+    // whole source read, not about the nodes this view kept.
+    if (lintMode === "report")
+        ir = { ...ir, meta: { ...ir.meta, lint: graphLintReport(lint, projectPath) } };
+    // The view capability rules read (#4378), mapped by this project's own
+    // lexicons, so a workspace's rules read each member as its chant maps it.
+    if (ctx.args.capabilityView) {
+        const { buildView, serializeView } = await import("../../capabilities/view.js");
+        const { resolvePacks } = await import("../../capabilities/catalog.js");
+        const packs = plugins.map((p) => p.capabilityPack).filter((p) => !!p);
+        ir = { ...ir, capabilityView: serializeView(buildView(ir, resolvePacks(packs))) };
+    }
     return emitIr(ir, ctx, format);
 }
 /** Emit a built IR in the requested view format — shared by the source

package/dist/cli/handlers/pr-env.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pr-env.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/pr-env.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AA2CH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAUlD,8CAA8C;AAC9C,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAO7E"}
+{"version":3,"file":"pr-env.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/pr-env.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AA0CH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAUlD,8CAA8C;AAC9C,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAO7E"}

package/dist/cli/handlers/pr-env.js

@@ -40,7 +40,8 @@ import { loadChantConfig } from "../../config.js";
 import { ENV_VAR } from "../../env.js";
 import { isEmptyChangeSet } from "../../change-set.js";
 import { PR_ENV_EXIT, PR_ENV_GATE, PR_ENV_RECORD_FILE, PR_ENV_REPORT_DIR, acceptHandedRecord, handedPrEnvReport, PR_ENV_TEMPLATE_VAR, derivePrEnvironment, prEnvApproveCommand, prEnvStatusState, prEnvironmentName, prEnvironmentSite, renderPrEnvNote, ttlMs, } from "../../components/pr-environment.js";
-import { commandTeardownAdapter, forgePrEnvPublisher, lifecyclePrEnvPorts, prEnvDown as prEnvDownRun, prEnvOp, prEnvSweep as prEnvSweepRun, prEnvUp as prEnvUpRun, } from "../../components/pr-env-run.js";
+import { commandTeardownAdapter, prEnvDown as prEnvDownRun, prEnvOp, prEnvSweep as prEnvSweepRun, prEnvUp as prEnvUpRun, } from "../../components/pr-env-run.js";
+import { forgePrEnvPublisher, lifecyclePrEnvPorts } from "../../components/pr-env-ports.js";
 import { applyPrSet } from "../../components/pr-run.js";
 import { prOp } from "../../pr-loop.js";
 import { FORGE_KINDS, forgeFromEnv, forgePrincipalOf } from "../../pr-forge.js";

package/dist/cli/handlers/search-count.d.ts

@@ -0,0 +1,89 @@
+import type { GraphIR, IRNode } from "../../graph-ir.js";
+import { terraformType } from "../../graph-effective.js";
+export { terraformType };
+/**
+ * `chant search --count-by <kind|module|attr:<name>>` (#4360): grouped counts
+ * over the matched set, one line per group, instead of one row per match.
+ *
+ * An agent asking "how many resources of each type does each module own" used
+ * to run one search per value, or read every row and count them itself. The
+ * second is the token cost `search` exists to avoid.
+ *
+ * Every matched node lands in exactly one group. A node with no value for the
+ * grouped dimension is counted under `(none)`, never dropped, so the groups
+ * always add up to the total line.
+ */
+export type CountBy = {
+    by: "kind";
+} | {
+    by: "module";
+} | {
+    by: "attr";
+    name: string;
+};
+/** The group a node with no value for the grouped dimension is counted under. */
+export declare const NONE_GROUP = "(none)";
+/** The module group of a Terraform block declared in the root module itself. */
+export declare const ROOT_MODULE_GROUP = "(root)";
+/** Parse a `--count-by` value, or say what the accepted spellings are. */
+export declare function parseCountBy(raw: string): CountBy | {
+    error: string;
+    hint: string;
+};
+/**
+ * The group one node belongs to.
+ *
+ * `module` on a Terraform node is its call chain. When the graph holds more
+ * than one Terraform root, the chain is prefixed with the root (`app/(root)`,
+ * `net/module.vpc`): `module.vpc` in two roots is two modules, applied
+ * separately, and counting them as one would add up resources that never sit
+ * in the same state. A node of another lexicon groups under the composite that
+ * expanded it, chant's own unit of reuse, or `(none)`.
+ */
+export declare function groupOf(n: IRNode, countBy: CountBy, multiRoot?: boolean): string;
+/** Whether the graph holds blocks from more than one Terraform root. */
+export declare function hasManyTerraformRoots(ir: GraphIR): boolean;
+/** Count `matches` per group, sorted by count (highest first) and then by name. */
+export declare function countGroups(matches: IRNode[], countBy: CountBy, multiRoot?: boolean): Array<{
+    group: string;
+    count: number;
+}>;
+/**
+ * The groups with the ids of the matches in each, in match order (#4382), in
+ * the order {@link countGroups} gives. `count` is always `ids.length`. A
+ * reader that draws the groups (behold#922) lights each group's nodes from
+ * `ids`, so it never has to read a node's group itself.
+ */
+export declare function groupMembers(matches: IRNode[], countBy: CountBy, multiRoot?: boolean): Array<{
+    group: string;
+    count: number;
+    ids: string[];
+}>;
+/** `--count-by` with `--json`: the groups, in printed order, each with its matched ids, and the total they add up to. */
+export interface CountsJson {
+    query: string;
+    source: unknown;
+    countBy: string;
+    groups: Array<{
+        group: string;
+        count: number;
+        ids: string[];
+    }>;
+    total: number;
+    liveFailures?: string[];
+}
+export declare function countsJson(query: string, source: unknown, groups: Array<{
+    group: string;
+    count: number;
+    ids: string[];
+}>, countBy: CountBy, liveFailures?: string[]): CountsJson;
+/**
+ * Render grouped counts: one `<count>  <group>` line per group, counts right
+ * aligned, then the total. The total is the number of matches, which is the
+ * sum of the group counts by construction.
+ */
+export declare function formatCounts(groups: Array<{
+    group: string;
+    count: number;
+}>, countBy: CountBy): string[];
+//# sourceMappingURL=search-count.d.ts.map

package/dist/cli/handlers/search-count.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-count.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/search-count.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAItD,OAAO,EAAE,aAAa,EAAE,CAAC;AAEzB;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,OAAO,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,QAAQ,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvF,iFAAiF;AACjF,eAAO,MAAM,UAAU,WAAW,CAAC;AACnC,gFAAgF;AAChF,eAAO,MAAM,iBAAiB,WAAW,CAAC;AAE1C,0EAA0E;AAC1E,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAUnF;AAiCD;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,UAAQ,GAAG,MAAM,CAQ9E;AAED,wEAAwE;AACxE,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,OAAO,GAAG,OAAO,CAI1D;AAED,mFAAmF;AACnF,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,UAAQ,GAAG,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAE3H;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,UAAQ,GAAG,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAW3I;AAED,yHAAyH;AACzH,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,wBAAgB,UAAU,CACxB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,EAC9D,OAAO,EAAE,OAAO,EAChB,YAAY,GAAE,MAAM,EAAO,GAC1B,UAAU,CASZ;AAOD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,EAAE,CAMxG"}

package/dist/cli/handlers/search-count.js

@@ -0,0 +1,132 @@
+import { terraformType } from "../../graph-effective.js";
+// The one reading of a terraform node's type lives with the folds that also
+// select on it, so `--count-by kind` and `kind:` cannot disagree (#4366).
+export { terraformType };
+/** The group a node with no value for the grouped dimension is counted under. */
+export const NONE_GROUP = "(none)";
+/** The module group of a Terraform block declared in the root module itself. */
+export const ROOT_MODULE_GROUP = "(root)";
+/** Parse a `--count-by` value, or say what the accepted spellings are. */
+export function parseCountBy(raw) {
+    const value = raw.trim();
+    if (value === "kind")
+        return { by: "kind" };
+    if (value === "module")
+        return { by: "module" };
+    const attr = /^attr:(.+)$/.exec(value);
+    if (attr && attr[1].trim())
+        return { by: "attr", name: attr[1].trim() };
+    return {
+        error: `--count-by "${raw}" is not a grouping`,
+        hint: "group by one of: --count-by kind, --count-by module, --count-by attr:<name>",
+    };
+}
+/** A Terraform node's root name, from its attrs or the first segment of its id. */
+function terraformRoot(n) {
+    const attrs = (n.attrs ?? {});
+    if (typeof attrs.root === "string")
+        return attrs.root;
+    const slash = n.id.indexOf("/");
+    return slash === -1 ? "" : n.id.slice(0, slash);
+}
+/**
+ * The module a Terraform node sits in: its call chain as Terraform writes it
+ * (`module.cdn`, `module.cdn.module.bucket`), or `(root)` for a block of the
+ * root module itself. The chain is on `attrs.callers`; an entity key
+ * `<root>/module.cdn/<address>` carries the same chain when it is absent.
+ */
+function terraformModule(n) {
+    const attrs = (n.attrs ?? {});
+    const callers = Array.isArray(attrs.callers)
+        ? attrs.callers.filter((c) => typeof c === "string")
+        : n.id.split("/").slice(1, -1);
+    return callers.length === 0 ? ROOT_MODULE_GROUP : callers.join(".");
+}
+/** An attribute's value as a group name, matched by exact name and then case-insensitively, as `--show` does. */
+function attrGroup(n, name) {
+    const attrs = (n.attrs ?? {});
+    const key = name in attrs ? name : Object.keys(attrs).find((k) => k.toLowerCase() === name.toLowerCase());
+    const v = key === undefined ? undefined : attrs[key];
+    if (v === undefined || v === null || v === "")
+        return NONE_GROUP;
+    return typeof v === "object" ? JSON.stringify(v) : String(v);
+}
+/**
+ * The group one node belongs to.
+ *
+ * `module` on a Terraform node is its call chain. When the graph holds more
+ * than one Terraform root, the chain is prefixed with the root (`app/(root)`,
+ * `net/module.vpc`): `module.vpc` in two roots is two modules, applied
+ * separately, and counting them as one would add up resources that never sit
+ * in the same state. A node of another lexicon groups under the composite that
+ * expanded it, chant's own unit of reuse, or `(none)`.
+ */
+export function groupOf(n, countBy, multiRoot = false) {
+    if (countBy.by === "kind")
+        return terraformType(n) ?? (n.kind || NONE_GROUP);
+    if (countBy.by === "attr")
+        return attrGroup(n, countBy.name);
+    if (n.lexicon === "terraform") {
+        const module = terraformModule(n);
+        return multiRoot ? `${terraformRoot(n) || NONE_GROUP}/${module}` : module;
+    }
+    return n.compositeParent || NONE_GROUP;
+}
+/** Whether the graph holds blocks from more than one Terraform root. */
+export function hasManyTerraformRoots(ir) {
+    const roots = new Set();
+    for (const n of ir.nodes)
+        if (n.lexicon === "terraform")
+            roots.add(terraformRoot(n));
+    return roots.size > 1;
+}
+/** Count `matches` per group, sorted by count (highest first) and then by name. */
+export function countGroups(matches, countBy, multiRoot = false) {
+    return groupMembers(matches, countBy, multiRoot).map(({ group, count }) => ({ group, count }));
+}
+/**
+ * The groups with the ids of the matches in each, in match order (#4382), in
+ * the order {@link countGroups} gives. `count` is always `ids.length`. A
+ * reader that draws the groups (behold#922) lights each group's nodes from
+ * `ids`, so it never has to read a node's group itself.
+ */
+export function groupMembers(matches, countBy, multiRoot = false) {
+    const ids = new Map();
+    for (const n of matches) {
+        const g = groupOf(n, countBy, multiRoot);
+        const list = ids.get(g);
+        if (list)
+            list.push(n.id);
+        else
+            ids.set(g, [n.id]);
+    }
+    return [...ids]
+        .map(([group, members]) => ({ group, count: members.length, ids: members }))
+        .sort((a, b) => b.count - a.count || (a.group < b.group ? -1 : a.group > b.group ? 1 : 0));
+}
+export function countsJson(query, source, groups, countBy, liveFailures = []) {
+    return {
+        query,
+        source,
+        countBy: countByLabel(countBy),
+        groups,
+        total: groups.reduce((sum, g) => sum + g.count, 0),
+        ...(liveFailures.length > 0 ? { liveFailures } : {}),
+    };
+}
+/** The label a `--count-by` value is printed with on the total line. */
+function countByLabel(countBy) {
+    return countBy.by === "attr" ? `attr:${countBy.name}` : countBy.by;
+}
+/**
+ * Render grouped counts: one `<count>  <group>` line per group, counts right
+ * aligned, then the total. The total is the number of matches, which is the
+ * sum of the group counts by construction.
+ */
+export function formatCounts(groups, countBy) {
+    const total = groups.reduce((sum, g) => sum + g.count, 0);
+    const width = String(groups[0]?.count ?? 0).length;
+    const lines = groups.map((g) => `${String(g.count).padStart(width)}  ${g.group}`);
+    lines.push(`— ${total} total · ${groups.length} group${groups.length === 1 ? "" : "s"} by ${countByLabel(countBy)}`);
+    return lines;
+}