@intentius/chant 0.124.26 → 0.124.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant",
-  "version": "0.124.26",
+  "version": "0.124.27",
   "description": "Declarative infrastructure-as-code toolkit — TypeScript on Node.js",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",

package/src/cli/compiled-cli.e2e.test.ts

@@ -18,6 +18,7 @@ import { execFileSync, spawnSync } from "node:child_process";
 import { mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
 import { afterAll, beforeAll, describe, expect, test } from "vitest";
 
 const coreRoot = resolve(import.meta.dirname, "..", "..");
@@ -37,12 +38,13 @@ const TRACER = `
 import { registerHooks } from "node:module";
 import { appendFileSync } from "node:fs";
 const out = process.env.CHANT_TRACE_OUT;
-const seen = { chantSrc: 0, chantDist: 0, tsx: 0 };
+const seen = { chantSrc: 0, chantDist: 0, tsx: 0, typescript: 0, dist: [] };
 registerHooks({
   load(url, context, next) {
     if (url.includes("/@intentius/chant/src/")) seen.chantSrc++;
-    else if (url.includes("/@intentius/chant/dist/")) seen.chantDist++;
+    else if (url.includes("/@intentius/chant/dist/")) { seen.chantDist++; seen.dist.push(url.slice(url.indexOf("/@intentius/chant/dist/") + 23)); }
     else if (url.includes("/node_modules/tsx/")) seen.tsx++;
+    else if (url.includes("/node_modules/typescript/")) seen.typescript++;
     return next(url, context);
   },
 });
@@ -59,14 +61,15 @@ interface Run {
   status: number | null;
   stdout: string;
   stderr: string;
-  loaded: { chantSrc: number; chantDist: number; tsx: number };
+  /** Counts of what loaded, plus each compiled module's path under `dist/`. */
+  loaded: { chantSrc: number; chantDist: number; tsx: number; typescript: number; dist: string[] };
 }
 
-function run(cwd: string, args: string[]): Run {
+function run(cwd: string, args: string[], extraEnv: NodeJS.ProcessEnv = {}, command = chant): Run {
   const traceOut = join(scratch, `trace-${Math.random().toString(36).slice(2)}.jsonl`);
-  const env: NodeJS.ProcessEnv = { ...process.env, NODE_OPTIONS: `--import ${tracer}`, CHANT_TRACE_OUT: traceOut };
+  const env: NodeJS.ProcessEnv = { ...process.env, ...extraEnv, NODE_OPTIONS: `--import ${tracer}`, CHANT_TRACE_OUT: traceOut };
   delete env.CHANT_ENV;
-  const result = spawnSync(chant, args, { cwd, env, encoding: "utf-8" });
+  const result = spawnSync(command, args, { cwd, env, encoding: "utf-8" });
   const lines = readFileSync(traceOut, "utf-8").trim().split("\n");
   return { status: result.status, stdout: result.stdout, stderr: result.stderr, loaded: JSON.parse(lines[0]!) as Run["loaded"] };
 }
@@ -192,6 +195,28 @@ describe("the installed chant CLI (#3878)", () => {
     expect(r.loaded).toMatchObject({ chantSrc: 0, tsx: 0 });
   });
 
+  test("workspace status on a steward-index miss loads no tsx for a member without Op files (#3976)", () => {
+    // A cache dir of its own, so there is no index to read and the member's stewards are discovered.
+    const r = run(join(workspace, "app"), ["workspace", "status", "local", "--json"], { CHANT_CACHE_DIR: mkdtempSync(join(scratch, "cache-")) });
+    expect(r.status, r.stderr).toBe(0);
+    const status = JSON.parse(r.stdout) as { members: Array<{ name: string; stewards: unknown[] }> };
+    expect(status.members.map((m) => [m.name, m.stewards])).toEqual([["app", []]]);
+    expect(r.loaded).toMatchObject({ chantSrc: 0, tsx: 0 });
+  });
+
+  test("importing the op entry loads the Op authoring surface, not lint, the LSP, codegen or typescript (#3982)", () => {
+    // Every *.op.ts imports @intentius/chant/op, so this is what a steward-index miss in `workspace status` pays per
+    // member with Op files. The base activities, which reach lint and typescript, load only when an Op runs.
+    const entry = join(project, "node_modules", "@intentius", "chant", "dist", "op", "index.js");
+    const script = `const op = await import(${JSON.stringify(pathToFileURL(entry).href)});\n` +
+      `if (typeof op.Op !== "function" || typeof op.factoryOp !== "function" || typeof op.declareSteward !== "function") process.exit(2);\n`;
+    const r = run(project, ["--input-type=module", "-e", script], {}, process.execPath);
+    expect(r.status, r.stderr).toBe(0);
+    expect(r.loaded).toMatchObject({ chantSrc: 0, tsx: 0, typescript: 0 });
+    const heavy = r.loaded.dist.filter((path) => /^(lint|lsp|codegen|mcp|audit|fold|cli)\//.test(path) || path === "index.js" || path === "op/activities/index.js");
+    expect(heavy).toEqual([]);
+  });
+
   test("build loads the TypeScript lexicon and project through tsx, against the one compiled core", () => {
     const r = run(project, ["build", "src", "-o", "out/render.json"]);
     expect(r.status, r.stderr).toBe(0);

package/src/op/activity-registry.ts

@@ -4,13 +4,15 @@
  *
  * The base activities are core's own (`./activities`): plain async functions
  * taking a single args object, with no workflow engine anywhere in the call
- * path. They are imported statically, so `loadActivities([])` works in a
- * project that has installed nothing but chant. Product-specific appliers stay
+ * path. They ship with core, so `loadActivities([])` works in a project that
+ * has installed nothing but chant. They are imported when activities are
+ * loaded, not when this module is: their implementations reach lint, codegen
+ * and `typescript`, and every `*.op.ts` imports `@intentius/chant/op`, which
+ * re-exports this module (#3982). Product-specific appliers stay
  * in their owning lexicon (#809) and are pulled in dynamically per the
  * project's configured lexicon list.
  */
 
-import * as baseActivities from "./activities";
 import { ACTIVITY_PROFILES, type ActivityProfile } from "./activity-profiles";
 import { importLexiconModule, importLexiconPackage } from "../lexicon-module";
 
@@ -63,13 +65,13 @@ function collectActivities(mod: Record<string, unknown>, into: Map<string, Activ
  * lexicon's activity of the same name; otherwise a later lexicon's export
  * replaces an earlier one's.
  *
- * Never throws: the base library is a static import, so there is no "no
+ * Never throws: the base library ships with core, so there is no "no
  * activities registered" state to report.
  */
 export async function loadActivities(lexicons: string[] = []): Promise<Map<string, ActivityFn>> {
   const activities = new Map<string, ActivityFn>();
 
-  collectActivities(baseActivities as unknown as Record<string, unknown>, activities);
+  collectActivities((await import("./activities")) as unknown as Record<string, unknown>, activities);
 
   for (const name of lexicons) {
     try {

package/src/op/discover-root.test.ts

@@ -170,3 +170,42 @@ describe("discoverOps: an Op may be exported by name (#2171)", () => {
     expect(errors[0]).toContain(`Duplicate Op name "twice" declared twice in`);
   });
 });
+
+/**
+ * #3976. Reading the project's `exclude`/`include` evaluates its config,
+ * which registers tsx, so discovery reads them only when an Op file could be
+ * found. An `exclude` that is not a list is an error whenever the config is
+ * read, which is how these tests tell whether it was.
+ */
+describe("discoverOps reads the config's globs only when there is an Op file (#3976)", () => {
+  let checkout: string;
+  beforeEach(() => {
+    checkout = realpathSync(mkdtempSync(join(tmpdir(), "chant-op-globs-")));
+    fakeGitRoot = checkout;
+    mkdirSync(join(checkout, "src"), { recursive: true });
+    writeFileSync(join(checkout, "src", "infra.ts"), "export const x = 1;\n");
+  });
+  afterEach(() => rmSync(checkout, { recursive: true, force: true }));
+
+  test("a project with no Op file has its config left unread", async () => {
+    writeFileSync(join(checkout, "chant.config.json"), JSON.stringify({ lexicons: ["aws"], exclude: 42 }));
+    const { ops, errors } = await discoverOps({ cwd: checkout });
+    expect(errors).toEqual([]);
+    expect([...ops.keys()]).toEqual([]);
+  });
+
+  test("with an Op file the config is read", async () => {
+    writeFileSync(join(checkout, "chant.config.json"), JSON.stringify({ lexicons: ["aws"], exclude: 42 }));
+    writeFileSync(join(checkout, "src", "run.op.ts"), OP_FILE("run"));
+    await expect(discoverOps({ cwd: checkout })).rejects.toThrow(/exclude/);
+  });
+
+  test("an Op file only `include` re-admits is still found", async () => {
+    writeFileSync(join(checkout, "chant.config.json"), JSON.stringify({ lexicons: ["aws"], include: [".ops"] }));
+    mkdirSync(join(checkout, ".ops"));
+    writeFileSync(join(checkout, ".ops", "hidden.op.ts"), OP_FILE("hidden"));
+    const { ops, errors } = await discoverOps({ cwd: checkout });
+    expect(errors).toEqual([]);
+    expect([...ops.keys()]).toEqual(["hidden"]);
+  });
+});

package/src/op/discover.ts

@@ -57,22 +57,29 @@ async function findDiscoveryRoot(cwd?: string): Promise<string> {
   return gitRoot;
 }
 
+const isOpFile = (name: string, full: string): boolean =>
+  name.endsWith(".op.ts") && !name.endsWith(".test.ts") && !name.endsWith(".spec.ts") && !hasDiscoveryMarkerSync(full);
+
 /**
  * Every `*.op.ts` file below the Op root, through the one discovery walk
  * (`../discovery/walk.ts`, #2527). The walk down stops at child projects
  * whatever the root is, so a configless layout whose Op root is the git root
  * no longer collects its sibling projects' Ops. The project's
  * `exclude`/`include` globs and the skip marker apply.
+ *
+ * The globs come from evaluating the project config, which registers tsx
+ * (#3976), so they are resolved only when an Op file could be found. A walk
+ * that includes `**` first reaches every path any `include` could re-admit,
+ * and stops at the first Op file. When it finds none, no globs could find
+ * one either.
  */
 async function collectOpFiles(root: string): Promise<string[]> {
-  return walkDiscovery({
-    walker: "ops",
-    root,
-    globs: await resolveDiscoveryGlobs(root),
-    excludeDirs: await workspaceMemberDirs(root),
-    accept: (name, full) =>
-      name.endsWith(".op.ts") && !name.endsWith(".test.ts") && !name.endsWith(".spec.ts") && !hasDiscoveryMarkerSync(full),
-  });
+  const excludeDirs = await workspaceMemberDirs(root);
+  // A limit of 0 ends the walk at the first file it accepts.
+  const any = { max: 0, truncated: false };
+  walkDiscovery({ walker: "ops", root, globs: { root, exclude: [], include: ["**"] }, excludeDirs, limit: any, accept: isOpFile });
+  if (!any.truncated) return [];
+  return walkDiscovery({ walker: "ops", root, globs: await resolveDiscoveryGlobs(root), excludeDirs, accept: isOpFile });
 }
 
 /** The `OpConfig` behind an exported value, or `undefined` when the value is not an Op. An Op entity carries its config on `.props` (`./resource.ts`); `name` and `phases` are what every consumer of a discovered Op reads. */

package/src/op/runtimes/local.ts

@@ -25,7 +25,6 @@ import { runOpLocally, OpRunFailure, type OpRunResult } from "../local-executor"
 import { loadActivityContracts } from "../activity-contract-registry";
 import { resumeGatesOf } from "../gate-checkpoint";
 import { stepHeartbeatMs } from "../step-console";
-import { runComponents } from "../../components/cli-support";
 import { discoverOps } from "../discover";
 import { readRunLedger, runEnvOf, DEFAULT_RUN_ENV } from "../../lifecycle/run-ledger";
 import type { OpConfig } from "../types";
@@ -237,7 +236,10 @@ export function createLocalOpRuntime(opts: { projectPath?: string } = {}): OpRun
       );
     },
 
-    runComponents(path, selector, options) {
+    async runComponents(path, selector, options) {
+      // Imported here, not at the top: the components driver is most of core's components tree, and this module is
+      // re-exported by `@intentius/chant/op`, which every `*.op.ts` imports (#3982).
+      const { runComponents } = await import("../../components/cli-support");
       return runComponents(path, selector, options);
     },
   };