@intentius/chant 0.58.0 → 0.60.0

package/src/cli/commands/lint.test.ts

@@ -1,9 +1,11 @@
 import { describe, test, expect, beforeEach, afterEach } from "vitest";
-import { lintCommand, isLintRule, loadPluginRules, type LintOptions } from "./lint";
+import { lintCommand, isLintRule, loadPluginRules, LEXICON_RESOLUTION_RULE_ID, type LintOptions } from "./lint";
+import { loadPlugins, resolveProjectLexicons } from "../plugins";
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
+import { params, setBuildParams } from "../../params";
 
 describe("lintCommand", () => {
   let testDir: string;
@@ -117,6 +119,69 @@ export default {
     ).toBe(true);
   });
 
+  // #2251 — `chant lint` imports every `*.op.ts` file to read the Op it
+  // declares, and an Op that takes a step argument from `params.<name>`
+  // (`@intentius/chant/params`) evaluates that read at module load. Before
+  // this, nothing populated the shared parameters object first, so every such
+  // argument was `undefined` and OPS012 reported the activity contract
+  // violated on source that builds and runs. The fixture imports the real
+  // params module by absolute path — `@intentius/chant/params` maps to the
+  // same file (packages/core/package.json's `exports`), so it is the one
+  // module record `lintCommand` mutates.
+  describe("build parameters reach an Op's step arguments (#2251)", () => {
+    const paramsModule = resolve(import.meta.dirname, "../../params.ts");
+
+    async function writeParamReadingOp(): Promise<void> {
+      await writeFile(
+        join(testDir, "mini.op.ts"),
+        `
+import { params } from ${JSON.stringify(paramsModule)};
+
+export default {
+  [Symbol.for("chant.declarable")]: true,
+  entityType: "Chant::Op",
+  lexicon: "chant",
+  kind: "resource",
+  props: {
+    name: "mini",
+    overview: "test",
+    phases: [
+      { name: "Greet", steps: [
+        { kind: "activity", fn: "shellCmd", args: { cmd: params.greeting } },
+      ] },
+    ],
+  },
+};
+        `,
+      );
+    }
+
+    test("OPS012 does not fire when the invocation's parameters are supplied", async () => {
+      await writeParamReadingOp();
+
+      const result = await lintCommand({
+        path: testDir,
+        format: "stylish",
+        buildParams: [{ name: "greeting", value: "echo hi", source: "default" }],
+      });
+
+      expect(result.diagnostics.filter((d) => d.ruleId === "OPS012")).toEqual([]);
+      expect(result.success).toBe(true);
+    });
+
+    test("OPS012 fires on the same source when no parameters are supplied", async () => {
+      await writeParamReadingOp();
+
+      const result = await lintCommand({ path: testDir, format: "stylish" });
+
+      expect(
+        result.diagnostics.some(
+          (d) => d.ruleId === "OPS012" && d.message.includes("args.cmd"),
+        ),
+      ).toBe(true);
+    });
+  });
+
   test("formats output as JSON", async () => {
     await writeFile(
       join(testDir, "nested.ts"),
@@ -541,3 +606,234 @@ describe("lintCommand — git-ignored files are not linted", () => {
     expect(result.diagnostics.some((d) => d.file.includes("authored.ts") && d.ruleId === "EVL003")).toBe(true);
   });
 });
+
+/**
+ * chant #2222 (epic #2215 sub-issue 7) — `chant lint` used to print "No
+ * problems found" and exit 0 on a project whose declared lexicon could not be
+ * resolved, the state `chant build` refuses outright. These pin both halves:
+ * the failure is now reported, and the one case the old `catch` legitimately
+ * covered (a project that declares no lexicon at all) still lints quietly.
+ */
+describe("lintCommand — a declared lexicon that cannot be resolved (#2222)", () => {
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `chant-lint-lexicon-${Date.now()}-${Math.random()}`);
+    await mkdir(join(testDir, "src"), { recursive: true });
+    await writeFile(join(testDir, "src", "clean.ts"), `export const x = 1;\n`);
+    process.env.NO_COLOR = "1";
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+    delete process.env.NO_COLOR;
+  });
+
+  /** The message `chant build` prints after `error: ` for the same project. */
+  async function buildsMessageFor(dir: string): Promise<string> {
+    try {
+      await loadPlugins(await resolveProjectLexicons(dir));
+    } catch (err) {
+      return err instanceof Error ? err.message : String(err);
+    }
+    throw new Error(`expected ${dir} to fail lexicon resolution`);
+  }
+
+  test("a declared lexicon whose package is not installed fails the lint", async () => {
+    await writeFile(
+      join(testDir, "chant.config.ts"),
+      `export default { lexicons: ["not-a-real-lexicon"] };\n`,
+    );
+
+    const result = await lintCommand({ path: testDir, format: "stylish" });
+
+    expect(result.success).toBe(false);
+    expect(result.errorCount).toBe(1);
+    const diag = result.diagnostics.find((d) => d.ruleId === LEXICON_RESOLUTION_RULE_ID);
+    expect(diag).toBeDefined();
+    expect(diag!.severity).toBe("error");
+    expect(diag!.file).toBe(join(testDir, "chant.config.ts"));
+    // Byte-for-byte what `chant build` reports, not a second wording.
+    expect(diag!.message).toBe(await buildsMessageFor(testDir));
+    expect(result.output).not.toContain("No problems found");
+  });
+
+  test("a chant.config that cannot be loaded at all fails the lint with its own error", async () => {
+    // The shape found in the wild: the config imports the lexicon package, so
+    // it throws before `lexicons` is ever read.
+    await writeFile(
+      join(testDir, "chant.config.ts"),
+      `import { thing } from "@intentius/chant-lexicon-not-a-real-lexicon";\n` +
+        `export default { lexicons: ["aws"], thing };\n`,
+    );
+
+    const result = await lintCommand({ path: testDir, format: "stylish" });
+
+    expect(result.success).toBe(false);
+    const diag = result.diagnostics.find((d) => d.ruleId === LEXICON_RESOLUTION_RULE_ID);
+    expect(diag).toBeDefined();
+    expect(diag!.message).toBe(await buildsMessageFor(testDir));
+    expect(diag!.message).toContain("@intentius/chant-lexicon-not-a-real-lexicon");
+  });
+
+  test("the failure reaches --format json", async () => {
+    await writeFile(
+      join(testDir, "chant.config.ts"),
+      `export default { lexicons: ["not-a-real-lexicon"] };\n`,
+    );
+
+    const result = await lintCommand({ path: testDir, format: "json" });
+
+    const parsed = JSON.parse(result.output) as Array<Record<string, unknown>>;
+    const entry = parsed.find((d) => d.ruleId === LEXICON_RESOLUTION_RULE_ID);
+    expect(entry).toBeDefined();
+    expect(entry!.severity).toBe("error");
+    expect(entry!.message).toBe(await buildsMessageFor(testDir));
+  });
+
+  test("the failure reaches --format sarif as an error-level result", async () => {
+    await writeFile(
+      join(testDir, "chant.config.ts"),
+      `export default { lexicons: ["not-a-real-lexicon"] };\n`,
+    );
+
+    const result = await lintCommand({ path: testDir, format: "sarif" });
+
+    const sarif = JSON.parse(result.output) as {
+      runs: Array<{ results: Array<{ ruleId: string; level: string; message: { text: string } }> }>;
+    };
+    const found = sarif.runs[0].results.find((r) => r.ruleId === LEXICON_RESOLUTION_RULE_ID);
+    expect(found).toBeDefined();
+    expect(found!.level).toBe("error");
+    expect(found!.message.text).toBe(await buildsMessageFor(testDir));
+  });
+
+  test("--fix does not drop the diagnostic", async () => {
+    await writeFile(
+      join(testDir, "chant.config.ts"),
+      `export default { lexicons: ["not-a-real-lexicon"] };\n`,
+    );
+
+    const result = await lintCommand({ path: testDir, format: "stylish", fix: true });
+
+    expect(result.success).toBe(false);
+    expect(result.diagnostics.some((d) => d.ruleId === LEXICON_RESOLUTION_RULE_ID)).toBe(true);
+  });
+
+  // The case the swallowed `catch` was written for, and the one that must not
+  // change: no `chant.config.*`, no lexicon import in any source file. The
+  // detection fallback throws "No lexicon detected in infrastructure files",
+  // which is a project that lints under the core rules alone.
+  test("a project with no chant.config at all still lints clean", async () => {
+    const result = await lintCommand({ path: testDir, format: "stylish" });
+
+    expect(result.success).toBe(true);
+    expect(result.diagnostics.some((d) => d.ruleId === LEXICON_RESOLUTION_RULE_ID)).toBe(false);
+    expect(result.output).toContain("No problems found");
+  });
+
+  test("a chant.config that declares no lexicons still lints clean", async () => {
+    await writeFile(join(testDir, "chant.config.ts"), `export default {};\n`);
+
+    const result = await lintCommand({ path: testDir, format: "stylish" });
+
+    expect(result.success).toBe(true);
+    expect(result.diagnostics.some((d) => d.ruleId === LEXICON_RESOLUTION_RULE_ID)).toBe(false);
+  });
+
+  test("a declared lexicon that does resolve lints clean", async () => {
+    await writeFile(join(testDir, "chant.config.ts"), `export default { lexicons: ["aws"] };\n`);
+
+    const result = await lintCommand({ path: testDir, format: "stylish" });
+
+    expect(result.success).toBe(true);
+    expect(result.diagnostics.some((d) => d.ruleId === LEXICON_RESOLUTION_RULE_ID)).toBe(false);
+  });
+});
+
+/**
+ * chant #2249 — `lintCommand` resolves the project's own declared
+ * `buildParams` when its caller supplied none, so an in-process lint agrees
+ * with `chant lint` on the command line.
+ *
+ * #2251 taught the CLI handler (../handlers/lint.ts) to resolve
+ * `--param`/`--params-file`/declared defaults and pass them down, because
+ * the OPS* checks import every `*.op.ts` file and an Op reading
+ * `params.<name>` evaluates that read at module load. Every other caller of
+ * `lintCommand` has no flags to read and passed nothing, so `params` stayed
+ * empty and OPS012 reported the activity contract violated for source that
+ * lints clean from a shell. That is how the root-examples gate
+ * (examples/root-examples-gate.test.ts) went red on github-pr-preview while
+ * `chant lint .` in the same directory exited 0, and it applied equally to
+ * `handleLint` over MCP and to test-utils' example harness.
+ *
+ * These drive the real `lintCommand` against a temp project holding one
+ * `*.op.ts` file (enough for the OPS* pass to run its parameter binding) and
+ * read the shared `params` object the binding populates.
+ */
+describe("lintCommand build-time parameters (#2249)", () => {
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `chant-lint-params-${Date.now()}-${Math.random()}`);
+    await mkdir(testDir, { recursive: true });
+    // The OPS* pass binds parameters only when there is an Op file to import.
+    // A plain default export is enough: it is skipped as not-an-Op after the
+    // binding has already happened.
+    await writeFile(join(testDir, "noop.op.ts"), `export default { props: {} };\n`);
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+    delete process.env.CHANT_TEST_ENV_2249;
+    setBuildParams({});
+  });
+
+  test("a declared default reaches params with no caller-supplied provenance", async () => {
+    await writeFile(
+      join(testDir, "chant.config.json"),
+      JSON.stringify({ buildParams: { env: { type: "string", default: "local" } } }),
+    );
+
+    await lintCommand({ path: testDir, format: "stylish" });
+
+    expect(params.env).toBe("local");
+  });
+
+  test("a declared env mapping reaches params the same way chant lint resolves it", async () => {
+    await writeFile(
+      join(testDir, "chant.config.json"),
+      JSON.stringify({
+        buildParams: { env: { type: "string", default: "local", env: "CHANT_TEST_ENV_2249" } },
+      }),
+    );
+    process.env.CHANT_TEST_ENV_2249 = "pr-42";
+
+    await lintCommand({ path: testDir, format: "stylish" });
+
+    expect(params.env).toBe("pr-42");
+  });
+
+  test("caller-supplied parameters win over the declared defaults", async () => {
+    await writeFile(
+      join(testDir, "chant.config.json"),
+      JSON.stringify({ buildParams: { env: { type: "string", default: "local" } } }),
+    );
+
+    await lintCommand({
+      path: testDir,
+      format: "stylish",
+      buildParams: [{ name: "env", value: "pr-42", source: "cli" }],
+    });
+
+    expect(params.env).toBe("pr-42");
+  });
+
+  test("a project declaring none binds an empty parameter set", async () => {
+    await writeFile(join(testDir, "chant.config.json"), JSON.stringify({}));
+
+    await lintCommand({ path: testDir, format: "stylish" });
+
+    expect(params).toEqual({});
+  });
+});

package/src/cli/commands/lint.ts

@@ -4,7 +4,7 @@ import { readFileSync, writeFileSync, readdirSync, statSync } from "fs";
 import { execFileSync } from "child_process";
 import { runLint, parseDisableComments } from "../../lint/engine";
 import type { LintRule, LintDiagnostic, LintFix } from "../../lint/rule";
-import type { IntrinsicDef } from "../../lexicon";
+import type { IntrinsicDef, LexiconPlugin } from "../../lexicon";
 import { loadPlugins, resolveProjectLexicons } from "../plugins";
 import { formatStylish, formatJson, formatSarif } from "../reporters/stylish";
 import { loadLocalRules } from "../../lint/rule-loader";
@@ -20,10 +20,14 @@ import { rule } from "../../lint/declarative";
 import { watchDirectory, formatTimestamp, formatChangedFiles } from "../watch";
 import { formatError, formatInfo } from "../format";
 import { GENERATED_MARKER } from "../../discovery/files";
+import { buildParamValues, resolveBuildParams } from "../../build-params";
+import { setBuildParams } from "../../params";
+import { isNoLexiconDetected } from "../../detectLexicon";
 
 // Import config loader
 import { loadConfig, resolveRulesForFile, resolveConfiguredSeverity, findProjectRoot } from "../../lint/config";
 import { loadChantConfig, resolveKnowledgeDir } from "../../config";
+import { findProjectConfig } from "../../project-root";
 import type { LintProjectConfig } from "../../lint/rule";
 import { loadOkfBundle, type OkfBundle } from "../../okf-read";
 
@@ -91,6 +95,40 @@ export async function loadPluginRules(
   return pluginRules;
 }
 
+/**
+ * The diagnostic id `chant lint` reports a lexicon it could not resolve under
+ * (chant #2222).
+ *
+ * Deliberately outside the COR/EVL/COMP/OPS families: those are *rules*, each
+ * with a `check()` the engine runs per file, a documented page, a configurable
+ * severity and a `chant-disable` escape hatch. This is none of those. It is
+ * the lint run reporting that it could not assemble the rule set the project
+ * asked for, so it is not silenceable through `rules: { ... : "off" }` or a
+ * disable comment. Silencing it would put back the exact "green on a broken
+ * project" this id exists to prevent.
+ */
+export const LEXICON_RESOLUTION_RULE_ID = "LEX001";
+
+/**
+ * Turn a lexicon-resolution failure into the error diagnostic `chant lint`
+ * reports it as. The message is the underlying error's own, unwrapped, so it
+ * is character-for-character what `chant build` prints after `error: ` for the
+ * same project (`loadPluginsOrExit`, ../main.ts): one failure, one wording.
+ *
+ * Attributed to the project's `chant.config.*` where there is one, since that
+ * is the file that names the lexicon; to the project root otherwise.
+ */
+function lexiconResolutionDiagnostic(projectRoot: string, error: Error): LintDiagnostic {
+  return {
+    file: findProjectConfig(projectRoot).configPath ?? projectRoot,
+    line: 1,
+    column: 1,
+    ruleId: LEXICON_RESOLUTION_RULE_ID,
+    severity: "error",
+    message: error.message,
+  };
+}
+
 /**
  * Load all lint rules: core COR/EVL rules, then lexicon plugin rules.
  *
@@ -103,7 +141,7 @@ export async function loadPluginRules(
  */
 async function loadAllPluginRules(
   projectPath: string,
-): Promise<{ rules: Map<string, LintRule>; intrinsics: IntrinsicDef[] }> {
+): Promise<{ rules: Map<string, LintRule>; intrinsics: IntrinsicDef[]; lexiconError?: Error }> {
   const rules = new Map<string, LintRule>();
 
   // Load core COR/EVL rules directly
@@ -111,16 +149,47 @@ async function loadAllPluginRules(
     rules.set(r.id, r);
   }
 
-  // Resolve project lexicons (e.g. ["aws"]) from config or detection
+  // Resolve project lexicons (e.g. ["aws"]) from config or detection, then
+  // load their plugins.
+  //
+  // chant #2222: a failure in either step is handed back to `lintCommand`
+  // (which reports it as {@link LEXICON_RESOLUTION_RULE_ID}) rather than
+  // swallowed or thrown. Both steps fail on the same project state: a
+  // `chant.config.ts` that names a lexicon whose package is not installed
+  // throws out of `loadPlugins`, and one that *imports* that package throws
+  // out of `resolveProjectLexicons` before the names are ever read. Before
+  // this, the first case crashed `chant lint` with a stack trace and the
+  // second was caught here and discarded, so `chant lint` printed "No
+  // problems found" and exited 0 on a project `chant build` refuses to
+  // build. A CI job that lints before it builds reported green on a project
+  // whose lexicon was missing.
+  //
+  // The one failure that stays quiet is the one the original `catch` was
+  // written for and named in its comment: a project that declares no
+  // `lexicons` and imports none from its source files, where the detection
+  // fallback throws `NO_LEXICON_DETECTED_MESSAGE`. That project lints under
+  // the core rules alone and always has. It is told apart by the exported
+  // sentinel rather than by a string literal copied to this file, so the two
+  // cannot drift apart.
   let lexiconNames: string[] = [];
+  let lexiconError: Error | undefined;
   try {
     lexiconNames = await resolveProjectLexicons(projectPath);
-  } catch {
-    // No lexicons detected — core rules only
+  } catch (err) {
+    if (!isNoLexiconDetected(err)) {
+      lexiconError = err instanceof Error ? err : new Error(String(err));
+    }
   }
 
   // Load only project lexicon plugins (no "chant" injection)
-  const plugins = await loadPlugins(lexiconNames);
+  let plugins: LexiconPlugin[] = [];
+  if (!lexiconError) {
+    try {
+      plugins = await loadPlugins(lexiconNames);
+    } catch (err) {
+      lexiconError = err instanceof Error ? err : new Error(String(err));
+    }
+  }
 
   // chant #1106 — the same plugins' registered intrinsics (`Ref`, `GetAtt`,
   // ...), so EVL001 can answer "does this call fold?" exactly like fold()
@@ -150,7 +219,7 @@ async function loadAllPluginRules(
     rules.set(r.id, r);
   }
 
-  return { rules, intrinsics };
+  return { rules, intrinsics, ...(lexiconError ? { lexiconError } : {}) };
 }
 
 /**
@@ -468,11 +537,21 @@ async function runComponentCheckDiagnostics(
 async function runOpCheckDiagnostics(
   infraPath: string,
   files: string[],
+  buildParams?: BuildParamProvenance[],
 ): Promise<{ diagnostics: LintDiagnostic[]; suppressed: Array<LintDiagnostic & { reason?: string }> }> {
   const config = loadConfig(findProjectRoot(infraPath));
   const opFiles = files.filter((f) => f.endsWith(".op.ts"));
   if (opFiles.length === 0) return { diagnostics: [], suppressed: [] };
 
+  // chant #2251 — the same step `discover()` runs before it imports or folds a
+  // project file (../../discovery/index.ts): populate the shared build-time
+  // parameters object BEFORE the imports below, so an Op that takes a step
+  // argument from `params.<name>` reads the value this invocation resolved
+  // rather than `undefined`. Unconditional, so a stale value from a prior
+  // lint in the same process (a test, `--watch`) never leaks into one that
+  // resolved none.
+  setBuildParams(buildParamValues(buildParams ?? []));
+
   const entities = new Map<string, unknown>();
   const fileByOpName = new Map<string, string>();
   for (const filePath of opFiles) {
@@ -573,10 +652,31 @@ export async function lintCommand(options: LintOptions): Promise<LintResult> {
   // than a failure — `loadOkfBundle` already treats a missing directory as
   // an empty bundle.
   let knowledgeBundle: OkfBundle | undefined;
+  /**
+   * chant #2249 — this invocation's build-time parameters, falling back to
+   * the project's own declared `buildParams` when the caller passed none.
+   *
+   * `chant lint` resolves them in ./handlers/lint.ts (#2251) because only
+   * the CLI knows about `--param`/`--params-file`, and passes them here. An
+   * in-process caller has no such flags to read, and before this fell
+   * through to the empty parameter object: the OPS* checks import each
+   * `*.op.ts`, an Op taking a step argument from `params.<name>` read
+   * `undefined` at module load, and OPS012 reported the activity contract
+   * violated for source `chant lint` on the command line passes. That made
+   * `lintCommand` disagree with its own CLI (the root-examples gate,
+   * `handleLint` over MCP, test-utils' example harness). Resolving the
+   * declared defaults + `env` mappings here is what the command line
+   * already gets; anything a flag would override still arrives in
+   * `options.buildParams` and wins. Best-effort like `projectConfig`:
+   * `resolveBuildParams` collects failures per parameter without throwing,
+   * and the ones that did resolve are still better than none.
+   */
+  let buildParams = options.buildParams;
   try {
     const chantConfig = (await loadChantConfig(projectRoot)).config;
     projectConfig = chantConfig as LintProjectConfig;
     knowledgeBundle = await loadOkfBundle(resolveKnowledgeDir(chantConfig, projectRoot));
+    buildParams ??= resolveBuildParams(chantConfig.buildParams, { env: process.env }).provenance;
   } catch {
     projectConfig = undefined;
     knowledgeBundle = undefined;
@@ -629,14 +729,14 @@ export async function lintCommand(options: LintOptions): Promise<LintResult> {
   // structurally distinct check family (whole-project, post-discovery,
   // see ../../lint/component-checks.ts) but the same `chant lint` output and
   // the same error-severity gating as every COR/EVL diagnostic.
-  const componentResult = await runComponentCheckDiagnostics(infraPath, options.sandbox, options.buildParams);
+  const componentResult = await runComponentCheckDiagnostics(infraPath, options.sandbox, buildParams);
   diagnostics.push(...componentResult.diagnostics);
   suppressed.push(...componentResult.suppressed);
 
   // Run the OPS* Op-model post-synth checks (#2122) over every `*.op.ts`
   // file under the lint target — see runOpCheckDiagnostics's doc for why
   // this needs no lexicon or build to fire.
-  const opResult = await runOpCheckDiagnostics(infraPath, files);
+  const opResult = await runOpCheckDiagnostics(infraPath, files, buildParams);
   diagnostics.push(...opResult.diagnostics);
   suppressed.push(...opResult.suppressed);
 
@@ -684,17 +784,25 @@ export async function lintCommand(options: LintOptions): Promise<LintResult> {
     // `*.component.ts` file on their behalf), but a fix applied to another
     // rule could still be in the same file a component was discovered from —
     // re-run for consistency with the AST re-lint above.
-    const postComponentResult = await runComponentCheckDiagnostics(infraPath, options.sandbox, options.buildParams);
+    const postComponentResult = await runComponentCheckDiagnostics(infraPath, options.sandbox, buildParams);
     diagnostics.push(...postComponentResult.diagnostics);
     suppressed.push(...postComponentResult.suppressed);
 
     // OPS* checks have no `.fix` either; re-run for the same consistency
     // reason as the COMP* re-run just above.
-    const postOpResult = await runOpCheckDiagnostics(infraPath, files);
+    const postOpResult = await runOpCheckDiagnostics(infraPath, files, buildParams);
     diagnostics.push(...postOpResult.diagnostics);
     suppressed.push(...postOpResult.suppressed);
   }
 
+  // chant #2222: a lexicon the project declared but this run could not
+  // resolve. Appended here, after the `--fix` re-lint block above has finished
+  // reassigning `diagnostics`, so it survives every path; it is a property of
+  // the run, not of any file a fix could touch.
+  if (loaded.lexiconError) {
+    diagnostics.push(lexiconResolutionDiagnostic(projectRoot, loaded.lexiconError));
+  }
+
   // Count errors and warnings
   let errorCount = 0;
   let warningCount = 0;

package/src/cli/handlers/graph.test.ts

@@ -710,10 +710,10 @@ describe("runGraph", () => {
       });
     });
 
-    // The bug this branch fixes (#57): a multi-stack, per-component project
-    // (loomster/Floci) has no stack literally named after the environment, so
-    // the live graph must resolve each component's own `cfn-deploy` stack(s)
-    // and pass them through to `observeResources` for the per-stack union.
+    // The bug this branch fixes (#57): a multi-stack, per-component project has
+    // no stack literally named after the environment, so the live graph must
+    // resolve each component's own `cfn-deploy` stack(s) and pass them through
+    // to `observeResources` for the per-stack union.
     test("multi-stack component project: resolves each component's cfn-deploy stack(s) and passes them to observeResources", async () => {
       resolveLexMock.mockResolvedValue(["aws"]);
       loadPluginsMock.mockResolvedValue([

package/src/cli/handlers/graph.ts

@@ -253,17 +253,17 @@ async function runGraphLive(
     return 1;
   }
 
-  // Multi-stack, per-component projects (loomster/Floci, #57): AWS's
-  // single-stack convention (`describeResources` defaults to a stack named
-  // after the environment, lexicons/aws/src/plugin.ts) never matches a
-  // per-component layout (e.g. `loom-local-a-<component>`), so the plain
-  // single call always observes zero nodes. Resolve every discovered
-  // component's `cfn-deploy` stack(s) — the same walk `chant components
-  // status --live` uses (`cfnDeployStacks`, ./components.ts) — and hand them
-  // to `observeResources`, which queries `describeResources` once per stack
-  // and unions the results. A project with no components (or whose discovery
-  // errors) yields no stacks, so `observeResources` falls back to its
-  // original single-stack call — unchanged.
+  // Multi-stack, per-component projects (#57): AWS's single-stack convention
+  // (`describeResources` defaults to a stack named after the environment,
+  // lexicons/aws/src/plugin.ts) never matches a per-component layout (e.g.
+  // `loom-local-a-<component>`), so the plain single call always observes zero
+  // nodes. Resolve every discovered component's `cfn-deploy` stack(s) — the
+  // same walk `chant components status --live` uses (`cfnDeployStacks`,
+  // ./components.ts) — and hand them to `observeResources`, which queries
+  // `describeResources` once per stack and unions the results. A project with
+  // no components (or whose discovery errors) yields no stacks, so
+  // `observeResources` falls back to its original single-stack call —
+  // unchanged.
   const componentsDiscovery = await discoverComponents(resolve(args.src ?? config.sourceDir ?? "."), {
     sandbox: args.sandbox,
   });