@intentius/chant 0.124.45 → 0.124.48

package/dist/workspace/conformance/index.js

@@ -54,7 +54,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { isDeepStrictEqual } from "node:util";
 import { READ_CONTRACT_VERSION } from "../reason-codes.js";
 /** The read-contract commands, as a reader names them. */
-export const READ_CONTRACT_COMMANDS = ["ls", "graph", "check", "status", "records", "records --uncommitted", "graph --intent", "graph --composites", "runs", "wip"];
+export const READ_CONTRACT_COMMANDS = ["ls", "graph", "check", "status", "records", "records --uncommitted", "graph --intent", "graph --composites", "runs", "wip", "search", "search --capabilities"];
 /**
  * Each command's output schema, beside this module's parent in `src/workspace/`.
  * The write commands' schemas (`records-new`, `records-amend`,
@@ -71,6 +71,10 @@ export const READ_CONTRACT_SCHEMAS = {
     "graph --composites": "composites.schema.json",
     runs: "runs.schema.json",
     wip: "wip.schema.json",
+    // `workspace search` (#4374). Plain `chant search --json` prints the same document for one project.
+    search: "search.schema.json",
+    // The capability catalog (#4375), from the workspace's chant.
+    "search --capabilities": "capabilities.schema.json",
 };
 /** The flags that ask each command for its JSON document. A reader adds one of these and nothing else. */
 export const READ_CONTRACT_JSON_FLAGS = {
@@ -84,6 +88,8 @@ export const READ_CONTRACT_JSON_FLAGS = {
     "graph --composites": [[], ["--json"]],
     runs: [["--json"]],
     wip: [["--json"]],
+    search: [["--json"]],
+    "search --capabilities": [["--json"]],
 };
 /** The arguments the suite passes each read, on the reference workspace or the generated one. */
 export const REFERENCE_READS = {
@@ -97,6 +103,9 @@ export const REFERENCE_READS = {
     "graph --composites": [],
     runs: [],
     wip: [],
+    // A bare word: on either workspace it searches the chant member, delivery, and lists the others.
+    search: ["app"],
+    "search --capabilities": [],
 };
 const here = dirname(fileURLToPath(import.meta.url));
 /** The package this module ships in: `packages/core` in the repository, `node_modules/@intentius/chant` when installed. */
@@ -261,6 +270,8 @@ export const MCP_READ_TOOLS = {
     "graph --intent": "workspace-graph",
     "graph --composites": "workspace-graph",
     runs: "workspace-runs",
+    search: "workspace-search",
+    "search --capabilities": "capabilities",
 };
 /**
  * The tool call that answers `chant <argv>`, a read-contract command with its
@@ -276,9 +287,14 @@ export function mcpToolCall(argv) {
     const args = {};
     const positional = [];
     const kinds = [];
+    const members = [];
     for (let i = 0; i < rest.length; i++) {
         const a = rest[i];
         const value = () => rest[++i];
+        if (a === "--") {
+            positional.push(...rest.slice(i + 1));
+            break;
+        }
         if (a === "--json")
             continue;
         if (a === "--format" && rest[i + 1] === "json") {
@@ -313,7 +329,21 @@ export function mcpToolCall(argv) {
             args.uncommitted = true;
         else if (a === "--composites")
             args.composites = true;
-        else if (a.startsWith("-"))
+        else if (verb === "search" && a === "--member")
+            members.push(value() ?? "");
+        else if (verb === "search" && a === "--env")
+            args.env = value();
+        else if (verb === "search" && a === "--snapshot")
+            args.snapshot = value();
+        else if (verb === "search" && a === "--count-by")
+            args.countBy = value();
+        else if (verb === "search" && a === "--show")
+            args.show = value();
+        else if (verb === "search" && a === "--explain")
+            args.explain = true;
+        else if (verb === "search" && a === "--capabilities")
+            args.capabilities = true;
+        else if (/^-[A-Za-z-]/.test(a))
             return undefined;
         else
             positional.push(a);
@@ -331,6 +361,13 @@ export function mcpToolCall(argv) {
             return positional.length === 0 ? { name: "workspace-graph", arguments: { ...args, ...(kinds.length ? { kind: kinds } : {}) } } : undefined;
         case "runs":
             return positional.length === 0 && kinds.length === 0 ? { name: "workspace-runs", arguments: args } : undefined;
+        case "search":
+            // The catalog (#4375) is its own tool, and takes nothing.
+            if (args.capabilities)
+                return positional.length === 0 && Object.keys(args).length === 1 && kinds.length === 0 && members.length === 0 ? { name: "capabilities", arguments: {} } : undefined;
+            return positional.length <= 1 && kinds.length === 0
+                ? { name: "workspace-search", arguments: { ...args, query: positional[0] ?? "", ...(members.length ? { member: members } : {}) } }
+                : undefined;
         default:
             return undefined;
     }

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"}