@intentius/chant 0.124.46 → 0.124.48

package/dist/workspace/composites.js

@@ -36,7 +36,8 @@
  * And each component lists the environments it may deploy to (#2695,
  * `environments.ts`): `local`, the environments its member's config declares,
  * and those with a release in the member's ledger on `chant/lifecycle`, with
- * the command line for each.
+ * the command line for each, and the forge workflow that deploys each one
+ * when the member's config names it (#4402).
  */
 import { formatError } from "../cli/format.js";
 import { joinLabel } from "../join-key.js";
@@ -44,7 +45,7 @@ import { readMemberIr } from "./compose-graph.js";
 import { workspaceGraph } from "./graph-cli.js";
 import { emitDocument } from "./member-commands.js";
 import { readerVersion, WORKSPACE_ERROR_CODES } from "./declaration.js";
-import { componentEnvironments, ENVIRONMENT_REASON_CODES, memberEnvironments, readLedgerEnvironments } from "./environments.js";
+import { componentEnvironments, ENVIRONMENT_REASON_CODES, EXECUTOR_REASON_CODES, memberEnvironments, readLedgerEnvironments } from "./environments.js";
 import { componentRuntimes, readRuntimesIn, RUNTIME_REASON_CODES } from "./runtimes.js";
 /** `$id` of the JSON Schema for the document, shipped beside this file. */
 export const COMPOSITES_OUTPUT_SCHEMA_ID = "https://intentius.io/chant/schemas/workspace/composites/v1/composites.schema.json";
@@ -69,6 +70,8 @@ export const COMPOSITES_REASON_CODES = [
 export const COMPOSITES_RUNTIME_REASON_CODES = RUNTIME_REASON_CODES;
 /** Why a member's environments are only `local`, or leave out one its ledger has (#2695). Closed. */
 export const COMPOSITES_ENVIRONMENT_REASON_CODES = ENVIRONMENT_REASON_CODES;
+/** Why an environment row's executor names no forge workflow (#4402). Closed. */
+export const COMPOSITES_EXECUTOR_REASON_CODES = EXECUTOR_REASON_CODES;
 /** Read one member's component graph run into components, or the reason it can't be read. */
 function readComponents(member, dir, run, runtimes, environments) {
     if (run.exitCode !== 0) {

package/dist/workspace/composites.schema.json

@@ -607,6 +607,28 @@
             }
           ]
         },
+        "executor": {
+          "description": "The forge and committed workflow that deploys this environment, as the member's chant.config.ts declares on the environment's entry (#4402): a literal entry before a pattern. forge and workflow are null when none is declared, and reason then says why. Never derived from a generated workflow's name. Added by chant 0.124.47; a document from an older chant has no executor.",
+          "type": "object",
+          "required": ["forge", "workflow", "reason"],
+          "properties": {
+            "forge": { "enum": ["github", "gitlab", "forgejo", null] },
+            "workflow": { "type": ["string", "null"], "description": "The workflow file the forge runs, such as deploy-prod.yml under .github/workflows/, or .gitlab-ci.yml." },
+            "reason": {
+              "oneOf": [
+                { "type": "null" },
+                {
+                  "type": "object",
+                  "required": ["code", "message"],
+                  "properties": {
+                    "code": { "enum": ["executor-none-declared", "executor-config-unreadable"] },
+                    "message": { "type": "string" }
+                  }
+                }
+              ]
+            }
+          }
+        },
         "command": {
           "type": "string",
           "description": "The command that deploys the component to this environment on its default runtime, run in the member's directory: chant run --components <name>, with --on <runtime> when the default runtime isn't local, and --env <env> for any environment but the default."

package/dist/workspace/conformance/__writer_fixture__/work/work.schema.json

@@ -79,7 +79,7 @@
       "uniqueItems": true
     },
     "evidence": {
-      "description": "The proof of done: public links, or workspace files pinned by the hash of their bytes (chant workspace records pin <path>). May be empty while the work is open; a done item with none gets the warning work-done-unpinned. An entry that names a criterion from acceptance carries the verification it is and its result, and a manual verdict names who gave it in by (#2772).",
+      "description": "The proof of done: public links, workspace files pinned by the hash of their bytes (chant workspace records pin <path>), or ops results on the chant/lifecycle branch (#3171). May be empty while the work is open; a done item with none gets the warning work-done-unpinned. An entry that names a criterion from acceptance carries the verification it is and its result, and a manual verdict names who gave it in by (#2772).",
       "type": "array",
       "items": {
         "oneOf": [
@@ -88,6 +88,9 @@
           },
           {
             "$ref": "#/definitions/evidencePin"
+          },
+          {
+            "$ref": "#/definitions/evidenceOps"
           }
         ]
       }
@@ -305,6 +308,107 @@
         ]
       }
     },
+    "evidenceOps": {
+      "description": "An ops result on the chant/lifecycle branch (#3171): a run, a deploy, a gate answer or a release plan, named the way graph --intent's trace names a link. chant workspace work evidence and the workEvidence activity check it against the ledger before writing it, and a cited run's outcome agrees with result.",
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "title",
+        "ops"
+      ],
+      "properties": {
+        "title": {
+          "type": "string",
+          "minLength": 1
+        },
+        "ops": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": [
+            "ledger",
+            "ref",
+            "field",
+            "value",
+            "sha256"
+          ],
+          "properties": {
+            "ledger": {
+              "description": "Which ledger: an Op run, a deploy record, a gate answer or a release plan.",
+              "enum": [
+                "run",
+                "deploy",
+                "gate",
+                "plan"
+              ]
+            },
+            "ref": {
+              "description": "The ledger file, as chant/lifecycle:<path>.",
+              "type": "string",
+              "pattern": "^chant/lifecycle:"
+            },
+            "field": {
+              "description": "The field of the record that picks it out of the file, such as id, runId, timestamp or digest.",
+              "type": "string",
+              "minLength": 1
+            },
+            "value": {
+              "description": "That field's value.",
+              "type": "string",
+              "minLength": 1
+            },
+            "sha256": {
+              "description": "Hex SHA-256 of the record as the ledger stores it: the line, or the plan file.",
+              "type": "string",
+              "pattern": "^[0-9a-f]{64}$"
+            },
+            "env": {
+              "description": "The environment, for a run or a deploy.",
+              "type": "string"
+            },
+            "outcome": {
+              "description": "The run's status, for a run.",
+              "enum": [
+                "ok",
+                "fail"
+              ]
+            }
+          }
+        },
+        "as_of": {
+          "description": "When the result was cited, as an ISO 8601 timestamp.",
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "criterion": {
+          "description": "The acceptance criterion this evidence is for, by id (#2772).",
+          "type": "string",
+          "pattern": "^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$"
+        },
+        "verification": {
+          "$ref": "#/definitions/verification"
+        },
+        "result": {
+          "description": "Whether the evidence shows the criterion met.",
+          "enum": [
+            "pass",
+            "fail"
+          ]
+        },
+        "by": {
+          "description": "Who produced the evidence: the lease holder for a steward's, the person for a manual verdict.",
+          "type": "string",
+          "minLength": 1
+        }
+      },
+      "dependencies": {
+        "criterion": [
+          "verification",
+          "result"
+        ]
+      }
+    },
     "evidencePin": {
       "description": "A file in the workspace, pinned by the hash of its bytes. chant workspace records reports a file that changed or went missing since.",
       "type": "object",

package/dist/workspace/cross-root-lint.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The disagreement lint (#2549, #2524 D6): `chant workspace lint --cross-root`.
+ *
+ * A member link is written down once, on the consumer. The members' graphs
+ * can surface the same relation on their own: a consumer's parameter that
+ * joins another member's output by name, or any relation a lexicon puts in
+ * its IR. The lint reports where the two disagree.
+ *
+ * It uses #1939's cross-build-root mode. Each composed member is one build
+ * root, read under the member's own toolchain as `chant workspace graph`
+ * reads it (`crossRootInputs` in `./workspace-run.ts`), and the composed
+ * graph's link table goes to every check as `ctx.links`. The checks are:
+ *
+ * - LNK001, core's own: the consumer declares a link to one member's output
+ *   while its graph joins a parameter of the same name to another member's.
+ * - every cross-root check a lexicon ships through `crossRootChecks()`, for
+ *   the lexicons the members' graphs name. A lexicon applies its own rule
+ *   once it surfaces the relation in its IR. One that can't be loaded here
+ *   is reported and skipped.
+ *
+ * Nothing runs unless `--cross-root` asks, so a plain `workspace lint`, and
+ * level 0, pay nothing for it.
+ */
+import type { CrossRootCheck, CrossRootLink, PostSynthCheck, PostSynthDiagnostic } from "../lint/post-synth.js";
+import type { WorkspaceGraph } from "./compose-graph.js";
+export declare const LNK001_ID = "LNK001";
+/** The links of the composed graph, as a cross-root check reads them. Ambiguous rows and record links are left out. */
+export declare function crossRootLinks(links: WorkspaceGraph["links"]): CrossRootLink[];
+/**
+ * LNK001: a declared link and a join the graph surfaces name different
+ * producers for the same handle. The consumer must be one of the run's roots,
+ * so its graph was read.
+ */
+export declare const lnk001: CrossRootCheck;
+/** What a cross-root lint run found. */
+export interface CrossRootLintResult {
+    findings: PostSynthDiagnostic[];
+    /** The checks that ran, by id. */
+    checks: string[];
+    /** Lexicons whose cross-root checks could not be loaded here, and why. */
+    unloaded: {
+        lexicon: string;
+        reason: string;
+    }[];
+}
+/** Loads a lexicon's cross-root checks; the plugin loader by default. */
+export type CrossRootCheckLoader = (lexicon: string) => Promise<ReadonlyArray<CrossRootCheck | PostSynthCheck>>;
+/**
+ * Run the disagreement lint over a composed graph: one root per composed
+ * member, LNK001, and the cross-root checks of every lexicon the roots name.
+ */
+export declare function crossRootLint(graph: WorkspaceGraph, opts?: {
+    env?: string;
+    load?: CrossRootCheckLoader;
+}): Promise<CrossRootLintResult>;
+//# sourceMappingURL=cross-root-lint.d.ts.map

package/dist/workspace/cross-root-lint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-root-lint.d.ts","sourceRoot":"","sources":["../../src/workspace/cross-root-lint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE7G,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGtD,eAAO,MAAM,SAAS,WAAW,CAAC;AAElC,uHAAuH;AACvH,wBAAgB,cAAc,CAAC,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC,GAAG,aAAa,EAAE,CAe9E;AAED;;;;GAIG;AACH,eAAO,MAAM,MAAM,EAAE,cA6BpB,CAAC;AAEF,wCAAwC;AACxC,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,mBAAmB,EAAE,CAAC;IAChC,kCAAkC;IAClC,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,0EAA0E;IAC1E,QAAQ,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACjD;AAED,yEAAyE;AACzE,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,aAAa,CAAC,cAAc,GAAG,cAAc,CAAC,CAAC,CAAC;AAQhH;;;GAGG;AACH,wBAAsB,aAAa,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,oBAAoB,CAAA;CAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAiBjJ"}

package/dist/workspace/cross-root-lint.js

@@ -0,0 +1,111 @@
+/**
+ * The disagreement lint (#2549, #2524 D6): `chant workspace lint --cross-root`.
+ *
+ * A member link is written down once, on the consumer. The members' graphs
+ * can surface the same relation on their own: a consumer's parameter that
+ * joins another member's output by name, or any relation a lexicon puts in
+ * its IR. The lint reports where the two disagree.
+ *
+ * It uses #1939's cross-build-root mode. Each composed member is one build
+ * root, read under the member's own toolchain as `chant workspace graph`
+ * reads it (`crossRootInputs` in `./workspace-run.ts`), and the composed
+ * graph's link table goes to every check as `ctx.links`. The checks are:
+ *
+ * - LNK001, core's own: the consumer declares a link to one member's output
+ *   while its graph joins a parameter of the same name to another member's.
+ * - every cross-root check a lexicon ships through `crossRootChecks()`, for
+ *   the lexicons the members' graphs name. A lexicon applies its own rule
+ *   once it surfaces the relation in its IR. One that can't be loaded here
+ *   is reported and skipped.
+ *
+ * Nothing runs unless `--cross-root` asks, so a plain `workspace lint`, and
+ * level 0, pay nothing for it.
+ */
+import { joinKey } from "../join-key.js";
+import { runCrossRootChecks } from "../lint/post-synth.js";
+import { crossRootInputs } from "./workspace-run.js";
+export const LNK001_ID = "LNK001";
+/** The links of the composed graph, as a cross-root check reads them. Ambiguous rows and record links are left out. */
+export function crossRootLinks(links) {
+    const out = [];
+    for (const row of links) {
+        const r = row;
+        if (typeof r.consumer !== "string" || typeof r.producer !== "string" || typeof r.output !== "string" || typeof r.origin !== "string")
+            continue;
+        out.push({
+            consumer: r.consumer,
+            producer: r.producer,
+            output: r.output,
+            origin: r.origin,
+            ...(typeof r.input === "string" || r.input === null ? { input: r.input } : {}),
+            ...(typeof r.status === "string" ? { status: r.status } : {}),
+        });
+    }
+    return out;
+}
+/**
+ * LNK001: a declared link and a join the graph surfaces name different
+ * producers for the same handle. The consumer must be one of the run's roots,
+ * so its graph was read.
+ */
+export const lnk001 = {
+    id: LNK001_ID,
+    description: "A declared member link and the join the members' graphs surface name different producers for the same output",
+    scope: "cross-root",
+    check(ctx) {
+        const links = ctx.links ?? [];
+        const findings = [];
+        const declared = links.filter((l) => l.origin === "declared" && l.status !== "invalid");
+        for (const inferred of links) {
+            if (!inferred.origin.startsWith("inferred:") || inferred.status !== "resolved")
+                continue;
+            if (!ctx.root(inferred.consumer))
+                continue;
+            const keys = new Set([joinKey(inferred.output), ...(inferred.input ? [joinKey(inferred.input)] : [])]);
+            for (const d of declared) {
+                if (d.consumer !== inferred.consumer || d.producer === inferred.producer)
+                    continue;
+                if (!keys.has(joinKey(d.output)))
+                    continue;
+                findings.push({
+                    checkId: LNK001_ID,
+                    severity: "warning",
+                    message: `${d.consumer} declares a link to ${d.producer}'s output ${d.output}, but its graph joins ` +
+                        `${inferred.input ? `parameter ${inferred.input}` : "a parameter"} to ${inferred.producer}'s output ${inferred.output}. ` +
+                        `Point the link at the member the graph reads from, or rename the parameter so it joins the declared output.`,
+                    root: d.consumer,
+                    entity: inferred.input ?? undefined,
+                });
+            }
+        }
+        return findings;
+    },
+};
+async function pluginChecks(lexicon) {
+    const { loadPlugin } = await import("../cli/plugins.js");
+    const plugin = await loadPlugin(lexicon);
+    return plugin.crossRootChecks?.() ?? [];
+}
+/**
+ * Run the disagreement lint over a composed graph: one root per composed
+ * member, LNK001, and the cross-root checks of every lexicon the roots name.
+ */
+export async function crossRootLint(graph, opts = {}) {
+    const roots = crossRootInputs(graph, opts.env);
+    const lexicons = [...new Set(roots.flatMap((r) => [...r.buildResult.entities.values()].map((e) => e.lexicon)))]
+        .filter((l) => typeof l === "string" && l !== "chant")
+        .sort();
+    const checks = [lnk001];
+    const unloaded = [];
+    for (const lexicon of lexicons) {
+        try {
+            checks.push(...(await (opts.load ?? pluginChecks)(lexicon)));
+        }
+        catch (err) {
+            unloaded.push({ lexicon, reason: err instanceof Error ? err.message.split("\n")[0] : String(err) });
+        }
+    }
+    const findings = runCrossRootChecks(checks, roots, { ...(opts.env ? { env: opts.env } : {}), links: crossRootLinks(graph.links) });
+    const ran = checks.filter((c) => c.scope === "cross-root").map((c) => c.id);
+    return { findings, checks: ran, unloaded };
+}

package/dist/workspace/dbt-models-reader.d.ts

@@ -0,0 +1,44 @@
+/**
+ * A dbt project's models as outputs (#3935), read beside its sources by the
+ * `dbt-project` reader.
+ *
+ * A model exposes `<schema>.<model>` and, for each column its YAML lists,
+ * `<schema>.<model>.<column>`, named by the contract of #3931: names as
+ * declared, Postgres case folding, never rendered per target. As with
+ * sources, nothing runs: dbt, Jinja and `profiles.yml` stay unread.
+ *
+ * - A model is a `.sql` file under the project's `model-paths`. Its name is
+ *   the file's name, or its `alias`. Python models, seeds and snapshots are
+ *   not read.
+ * - `enabled`, `schema` and `alias` come from the first of: the model's own
+ *   `{{ config(...) }}`, the `config:` of its entry in a model YAML, then the
+ *   `+` keys of `dbt_project.yml` that match the model's path (the project's
+ *   name, each directory under the model path, the model's name), the
+ *   deepest first.
+ * - The schema is the member's `modelSchema` field when it is set, and
+ *   dbt's config is then not read for it. Otherwise it is the schema dbt
+ *   config names, but dbt's default `generate_schema_name` joins the target's
+ *   schema to a custom one (`<target_schema>_<custom>`), and a model with no
+ *   custom schema lands in the target's schema, so the name depends on the
+ *   target. The model is then a gap that says to set `modelSchema`. The
+ *   exception is a project whose `generate_schema_name` macro is the usual
+ *   override (the custom schema as it stands, the target's schema when there
+ *   is none): a model with a custom schema is named by it. Any other
+ *   override is not evaluated, and every model is a gap.
+ * - A templated schema, alias or `enabled`, or one that is not a plain
+ *   string, is a gap; chant never renders it.
+ */
+import type { KindLinkRead, KindReaderInput } from "./kind-link-readers.js";
+import { type Dialect, type Quoting } from "./dbt-project-common.js";
+export interface DbtModelsContext {
+    input: KindReaderInput;
+    project: Record<string, unknown>;
+    projectFile: string;
+    /** The tree-relative model paths, already checked. */
+    paths: string[];
+    quoting: Quoting;
+    dialect: Dialect;
+    result: KindLinkRead;
+}
+export declare function readDbtModels(ctx: DbtModelsContext): void;
+//# sourceMappingURL=dbt-models-reader.d.ts.map

package/dist/workspace/dbt-models-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dbt-models-reader.d.ts","sourceRoot":"","sources":["../../src/workspace/dbt-models-reader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAIH,OAAO,KAAK,EAAkB,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACzF,OAAO,EAQL,KAAK,OAAO,EACZ,KAAK,OAAO,EACb,MAAM,sBAAsB,CAAC;AAG9B,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,eAAe,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,sDAAsD;IACtD,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,YAAY,CAAC;CACtB;AAcD,wBAAgB,aAAa,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI,CAmHzD"}