@intentius/chant 0.66.1 → 0.67.0

package/src/lifecycle/scenario-cost.test.ts

@@ -105,12 +105,12 @@ describe("evaluateScenario — cost against the fixture's recorded prediction",
   });
 
   test("a fixture whose prediction is a refusal fails with the refusal's reason, never a pass on nothing", () => {
-    const verdict = evaluateScenario(EMPTY, { cost: { maxPerHour: 1e9, currency: "USD" } }, { result: noBehaviourEngineRefusal("augur") });
+    const verdict = evaluateScenario(EMPTY, { cost: { maxPerHour: 1e9, currency: "USD" } }, { result: noBehaviourEngineRefusal("chant") });
     expect(verdict.pass).toBe(false);
     expect(cost(verdict).detail).toContain("the fixture's prediction is a refusal (no-engine)");
     expect(cost(verdict).detail).toContain("Set CHANT_BEHAVIOUR_ENGINE to the engine's address.");
 
-    const broke = outOfCreditBehaviourEngineRefusal("augur", { value: "engine", source: "CHANT_BEHAVIOUR_ENGINE" }, "balance 0");
+    const broke = outOfCreditBehaviourEngineRefusal("chant", { value: "engine", source: "CHANT_BEHAVIOUR_ENGINE" }, "balance 0");
     expect(cost(evaluateScenario(EMPTY, { cost: { maxPerHour: 1e9, currency: "USD" } }, { result: broke })).detail).toContain("engine-out-of-credit");
   });
 

package/src/op/activities/index.ts

@@ -137,8 +137,7 @@ export {
   baseRefFrom,
   headRefFrom,
   noBaseRefMessage,
-  noPredictingLexiconMessage,
-  ambiguousPredictorMessage,
+  noContributedRowsMessage,
 } from "./predict-behaviour";
 export type {
   PredictBehaviourArgs,

package/src/op/activities/predict-behaviour.test.ts

@@ -5,6 +5,7 @@
  */
 
 import { describe, expect, test, vi } from "vitest";
+import { coverageFor, type BehaviourKinds } from "../../behaviour-kinds";
 import {
   behaviourReport,
   noBehaviourEngineRefusal,
@@ -15,14 +16,13 @@ import {
 } from "../../behaviour";
 import { commentMarker, issueMarker, type ReconcilePrArgs, type ReconcileResult } from "./reconcile";
 import {
-  ambiguousPredictorMessage,
   baseRefFrom,
   behaviourFindingMarker,
   createBehaviourFinding,
   declaredEdgeCoverage,
   headRefFrom,
   noBaseRefMessage,
-  noPredictingLexiconMessage,
+  noContributedRowsMessage,
   type BaseCheckout,
 } from "./predict-behaviour";
 
@@ -97,12 +97,25 @@ describe("declaredEdgeCoverage — never complete on the declared path", () => {
 
 describe("the refusals for a project that cannot predict", () => {
   test("no predicting lexicon names the configured ones and what to add", () => {
-    expect(noPredictingLexiconMessage(["aws", "k8s"])).toMatch(/\(aws, k8s\).*augur.*CHANT_BEHAVIOUR_ENGINE/s);
-    expect(noPredictingLexiconMessage([])).toContain("(none)");
+    // Not an error any more: with rows contributed per lexicon there is
+    // nothing to choose between, and an estate whose lexicons contribute no
+    // rows is a real state with a real answer rather than a broken command
+    // (#2382).
+    expect(noContributedRowsMessage(["aws", "k8s"])).toMatch(/\(aws, k8s\).*behaviourKinds.*CHANT_BEHAVIOUR_ENGINE/s);
+    expect(noContributedRowsMessage([])).toContain("(none)");
+    expect(noContributedRowsMessage(["aws"])).toContain("unknown-type");
   });
 
-  test("two predicting lexicons is refused rather than merged", () => {
-    expect(ambiguousPredictorMessage(["augur", "other"])).toMatch(/2 configured lexicons.*\(augur, other\)/);
+  test("two lexicons contributing rows is ordinary, not a conflict", () => {
+    // The old shape refused here, because two lexicons implementing
+    // predictBehaviour() meant two engines pricing one estate. Rows do not
+    // have that problem: each lexicon speaks only about its own entity types,
+    // so contributions are additive and there is nothing to merge.
+    const aws: BehaviourKinds = { provider: "aws", prefixes: ["AWS::"], mapped: { "AWS::S3::Bucket": { kind: "object-store" } } };
+    const k8s: BehaviourKinds = { provider: "kubernetes", prefixes: ["K8s::"], mapped: { "K8s::Core::Pod": { kind: "compute" } } };
+    expect(coverageFor([aws, k8s], "AWS::S3::Bucket").status).toBe("mapped");
+    expect(coverageFor([aws, k8s], "K8s::Core::Pod").status).toBe("mapped");
+    expect(coverageFor([k8s, aws], "AWS::S3::Bucket").status).toBe("mapped");
   });
 });
 
@@ -198,7 +211,7 @@ describe("behaviourFinding — predicts both sides, differences them, and posts
   });
 
   test("a refusal on the base side posts a finding that says no prediction, and flags the run", async () => {
-    const { run, posted } = harness({ base: noBehaviourEngineRefusal("augur"), head: report({ db: figure(0.1) }) });
+    const { run, posted } = harness({ base: noBehaviourEngineRefusal("chant"), head: report({ db: figure(0.1) }) });
     const result = await run({ environment: "prod", traffic: TRAFFIC, op: "pr-behaviour" });
     expect(result.refused).toBe(true);
     expect(result.finding.kind).toBe("no-prediction");

package/src/op/activities/predict-behaviour.ts

@@ -55,7 +55,7 @@
  * `partial` either, because `partial` has to name a gap as `dangling` or
  * `unresolvedKinds`, and the gap here is neither — every reference resolved,
  * and the generic builder has no vocabulary for "this kind is a boundary
- * whose containment is missing" (augur's own fixture names its boundary
+ * whose containment is missing" (the request fixture names its boundary
  * kinds by hand, which is lexicon knowledge core does not have). An earlier
  * draft named every kind no reference touched, and named a queue nobody
  * references as "unresolved", which it is not. So the claim is `unknown`,
@@ -81,6 +81,8 @@ import {
   type BehaviourDelta,
 } from "../../behaviour-delta";
 import type { LexiconPlugin } from "../../lexicon";
+import type { BehaviourKinds } from "../../behaviour-kinds";
+import { createBehaviourPredict } from "../../behaviour-predict";
 import type { SerializerResult } from "../../serializer";
 import { markerSlug, reconcilePr, suppliedMarker, type ReconcileResult } from "./reconcile";
 
@@ -107,22 +109,23 @@ export interface PredictBehaviourArgs {
   owned?: boolean;
 }
 
-/** What the activity says when no configured lexicon implements the fourth method. */
-export function noPredictingLexiconMessage(lexicons: readonly string[]): string {
+/**
+ * What the activity says when nothing has contributed coverage rows.
+ *
+ * Not an error and not a refusal: the prediction runs, every declared entity
+ * is withheld as `unknown-type`, and this is what the report's own detail says
+ * one level down. Kept as a message rather than a throw because an estate
+ * whose lexicons contribute no rows is a real state with a real answer — "no
+ * row says what any of these are" — and a throw would turn it into a broken
+ * command (#2382).
+ */
+export function noContributedRowsMessage(lexicons: readonly string[]): string {
   const configured = lexicons.length > 0 ? lexicons.join(", ") : "(none)";
   return (
-    "predictBehaviour has the estate to predict and no lexicon to predict it with: none of the configured " +
-    `lexicons (${configured}) implements predictBehaviour(). Add augur to \`lexicons\` in chant.config.ts — it ` +
-    "reads whatever the other lexicons declare — and set CHANT_BEHAVIOUR_ENGINE to the engine's address."
-  );
-}
-
-/** What the activity says when more than one configured lexicon predicts. */
-export function ambiguousPredictorMessage(names: readonly string[]): string {
-  return (
-    `predictBehaviour found ${names.length} configured lexicons that implement predictBehaviour() (${names.join(", ")}) ` +
-    "and predicts with one. Two engines pricing one estate is a merge this activity does not do, because an entity " +
-    "priced twice has two provenances and one row; configure one predicting lexicon."
+    "predictBehaviour has the estate to predict and no coverage rows to read it with: none of the " +
+    `configured lexicons (${configured}) contributes \`behaviourKinds\`. Every entity will be reported ` +
+    "unpredicted as `unknown-type`. Set CHANT_BEHAVIOUR_ENGINE to the engine's address, and add rows " +
+    "in the lexicon that owns the entity types you expect priced."
   );
 }
 
@@ -157,10 +160,10 @@ export async function predictDeclared(projectPath: string, args: PredictBehaviou
   const { config } = await loadChantConfigUpward(projectPath);
   const lexicons = await resolveProjectLexicons(projectPath);
   const plugins = (await loadPlugins(lexicons)) as LexiconPlugin[];
-  const predictors = plugins.filter((p) => typeof p.predictBehaviour === "function");
-  if (predictors.length === 0) throw new Error(noPredictingLexiconMessage(lexicons));
-  if (predictors.length > 1) throw new Error(ambiguousPredictorMessage(predictors.map((p) => p.name)));
-  const [predictor] = predictors;
+  // Rows, not a predictor. Since #2382 core predicts and each lexicon says
+  // only what its own entity types mean, so there is nothing to choose between
+  // and nothing to refuse when two lexicons both answer — they are additive.
+  const kinds = plugins.map((p) => p.behaviourKinds).filter((k): k is BehaviourKinds => k !== undefined);
 
   const sourceDir = resolve(projectPath, config.sourceDir ?? ".");
   const result = await build(sourceDir, plugins.map((p) => p.serializer));
@@ -169,11 +172,10 @@ export async function predictDeclared(projectPath: string, args: PredictBehaviou
     throw new Error(`predictBehaviour: the project under ${projectPath} did not build: ${messages.join("; ")}`);
   }
 
-  // Every declared entity with a type, the way augur's own request fixture
-  // assembles it: the predicting lexicon decides what reaches the engine and
-  // what is declared unmapped, and it can only decide about what it is
-  // handed. Filtering here to "resources" would silently drop the kinds the
-  // coverage table exists to name.
+  // Every declared entity with a type. The contributed rows decide what
+  // reaches the engine and what is declared unmapped, and they can only decide
+  // about what they are handed: filtering here to "resources" would silently
+  // drop the kinds the coverage rows exist to name.
   const entities = new Map<string, { entityType: string; props: Record<string, unknown> }>();
   for (const [name, entity] of result.entities) {
     const declarable = entity as { entityType?: unknown; props?: unknown };
@@ -185,11 +187,11 @@ export async function predictDeclared(projectPath: string, args: PredictBehaviou
   }
   const edges = buildGraphIr(result.entities, sourceDir).edges;
 
-  // The predicting lexicon's own serialized output, as the deep read is handed
-  // its lexicon's — a string, not a path (cli/handlers/lifecycle.ts). augur
-  // reads nothing off it; the mirror is kept so a lexicon that does gets what
-  // the other three methods get.
-  const raw = result.outputs.get(predictor.name);
+  // The build output the other three reads are handed — a string, not a path
+  // (cli/handlers/lifecycle.ts). Nothing on this path reads it; the mirror is
+  // kept so the four methods take the same shape. With no predicting lexicon
+  // to take it from, it is the first output the build produced, or empty.
+  const raw = [...result.outputs.values()][0];
   const buildOutput = raw === undefined ? "" : typeof raw === "string" ? raw : (raw as SerializerResult).primary;
 
   const options: PredictBehaviourOptions = {
@@ -204,7 +206,7 @@ export async function predictDeclared(projectPath: string, args: PredictBehaviou
     edges,
     edgeCoverage: declaredEdgeCoverage(),
   };
-  const answer = await predictor.predictBehaviour!(options);
+  const answer = await createBehaviourPredict({ kinds })(options);
   // On arrival, with the names that were asked — `behaviourReport` checks the
   // ordinary route and says a consumer that needs the guarantee checks again.
   return validateBehaviourResult(answer, options.entityNames);