@intentius/chant 0.57.0 → 0.59.0

package/src/cli/commands/init-lexicon.test.ts

@@ -1,10 +1,11 @@
 import { describe, test, expect, beforeEach, afterEach } from "vitest";
-import { existsSync, readFileSync, mkdirSync, writeFileSync, rmSync, readdirSync, realpathSync } from "fs";
+import { existsSync, readFileSync, mkdirSync, writeFileSync, rmSync, readdirSync, realpathSync, symlinkSync } from "fs";
 import { execFileSync } from "child_process";
 import { join, dirname } from "path";
 import { tmpdir } from "os";
-import { fileURLToPath } from "url";
+import { fileURLToPath, pathToFileURL } from "url";
 import { initLexiconCommand } from "./init-lexicon";
+import { checkLexicon } from "./check-lexicon";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const FIXTURE_DIR = join(__dirname, "__fixtures__", "init-lexicon-output");
@@ -44,6 +45,8 @@ describe("initLexiconCommand", () => {
       "src/codegen/naming.ts",
       "src/codegen/package.ts",
       "src/codegen/docs.ts",
+      "src/codegen/docs-cli.ts",
+      "src/package-cli.ts",
       "src/spec/fetch.ts",
       "src/spec/parse.ts",
       "src/lint/rules/sample.ts",
@@ -245,6 +248,16 @@ describe("scaffold content validation", () => {
     expect(pkg.scripts.build).toContain("tsconfig.build.json");
   });
 
+  // #2090, the scaffolded package.json failed tier 1 as generated: a bare
+  // string exports["."], a build script that never deletes emitted .js, and
+  // a prepack that never bundled, so dist/manifest.json never existed.
+  test("package.json exports[\".\"].default is ./src/index.ts, build deletes emitted JS, prepack bundles (#2090)", () => {
+    const pkg = JSON.parse(readFileSync(join(targetDir, "package.json"), "utf-8"));
+    expect(pkg.exports["."].default).toBe("./src/index.ts");
+    expect(pkg.scripts.build).toContain("-delete");
+    expect(pkg.scripts.prepack).toContain("bundle");
+  });
+
   test("tsconfig.build.json uses bundler resolution + the development condition (#749)", () => {
     const cfg = JSON.parse(readFileSync(join(targetDir, "tsconfig.build.json"), "utf-8"));
     expect(cfg.compilerOptions.moduleResolution).toBe("bundler");
@@ -308,6 +321,88 @@ describe("scaffold content validation", () => {
   });
 });
 
+// #2090, a fresh scaffold used to fail 5 tier-1 checks before the author
+// wrote anything. The docs-cli.ts gap (section 1) and the package.json/bundle
+// gap (section 2) together fixed the packaging-shape check and let
+// `npm run bundle` actually produce dist/manifest.json with a chantVersion.
+describe("a fresh scaffold's tier-1 completeness (#2090)", () => {
+  let root: string;
+  let dir: string;
+
+  beforeEach(async () => {
+    root = join(tmpdir(), `chant-scaffold-tier1-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(root, { recursive: true });
+    // The scaffold's tsconfig.json extends "../../tsconfig.json" (mirroring
+    // lexicons/<name>/tsconfig.json's real "../../tsconfig.json" -> repo
+    // root), so loading it needs a real file two levels up.
+    writeFileSync(join(root, "tsconfig.json"), "{}\n");
+
+    // A self-contained node_modules so the scaffold's own runtime imports of
+    // "@intentius/chant/*" resolve exactly as they would in the real
+    // monorepo, without touching the real repo's node_modules or lexicons/.
+    mkdirSync(join(root, "node_modules/@intentius"), { recursive: true });
+    symlinkSync(
+      join(__dirname, "..", "..", ".."), // commands -> cli -> src -> packages/core
+      join(root, "node_modules/@intentius/chant"),
+      "dir",
+    );
+
+    dir = join(root, "lexicons", "acme");
+    await initLexiconCommand({ name: "acme", path: dir });
+
+    // Bypass the generate() TODO throw. A real spec fetcher/parser is the
+    // author's job, not this test's. writeGeneratedFiles resolves its own
+    // target so a no-op stub is fine.
+    writeFileSync(
+      join(dir, "src/codegen/generate.ts"),
+      [
+        "export async function generate() {",
+        "  return { resources: 0, properties: 0, enums: 0, lexiconJSON: '{}', typesDTS: '', indexTS: '' };",
+        "}",
+        "export function writeGeneratedFiles() {}",
+        "",
+      ].join("\n"),
+    );
+
+    // Run the fixed bundle pipeline for real, proving section 2's package.json
+    // + package-cli.ts changes actually produce dist/manifest.json, not just
+    // that the scripts look right.
+    const packageMod = (await import(pathToFileURL(join(dir, "src/codegen/package.ts")).href)) as {
+      packageLexicon: (opts?: { verbose?: boolean }) => Promise<{ spec: unknown }>;
+    };
+    const { spec } = await packageMod.packageLexicon({ verbose: false });
+
+    const bundleMod = (await import(
+      pathToFileURL(join(root, "node_modules/@intentius/chant/src/codegen/package.ts")).href
+    )) as { writeBundleSpec: (spec: unknown, distDir: string) => void };
+    bundleMod.writeBundleSpec(spec, join(dir, "dist"));
+  });
+
+  afterEach(() => {
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test("the fixed bundle pipeline actually produces dist/manifest.json with a chantVersion", () => {
+    expect(existsSync(join(dir, "dist/manifest.json"))).toBe(true);
+    const manifest = JSON.parse(readFileSync(join(dir, "dist/manifest.json"), "utf-8"));
+    expect(typeof manifest.chantVersion).toBe("string");
+    expect(manifest.chantVersion.length).toBeGreaterThan(0);
+  });
+
+  // Only real author work should remain. "Every shipped example builds..."
+  // also fails here, but for a reason outside this issue's scope: the
+  // scaffold's getting-started example has every line commented out (nothing
+  // to build yet), which is true independent of sections 1 and 2 above.
+  test("fails only on real author work, not on anything sections 1-2 fix", async () => {
+    const result = await checkLexicon(dir);
+    const tier1Failures = result.items.filter((i) => i.tier === 1 && !i.pass).map((i) => i.name);
+    expect(tier1Failures).toEqual([
+      "postSynthChecks() returns at least 1 check",
+      "Every shipped example builds and passes its own post-synth checks",
+    ]);
+  });
+});
+
 // ── Fixture snapshot tests ──────────────────────────────────────────
 
 describe("init-lexicon fixture snapshot", () => {

package/src/cli/commands/init-lexicon.ts

@@ -4,11 +4,11 @@ import { formatSuccess, formatWarning } from "../format";
 
 // Template generators
 import { generatePluginTs, generateIndexTs } from "./init-lexicon/templates/plugin";
-import { generateCodegenGenerateTs, generateCodegenGenerateCliTs, generateCodegenNamingTs, generateCodegenPackageTs, generateCodegenDocsTs } from "./init-lexicon/templates/codegen";
+import { generateCodegenGenerateTs, generateCodegenGenerateCliTs, generateCodegenNamingTs, generateCodegenPackageTs, generateCodegenDocsTs, generateCodegenDocsCliTs } from "./init-lexicon/templates/codegen";
 import { generateSpecFetchTs, generateSpecParseTs } from "./init-lexicon/templates/spec";
 import { generateSampleRuleTs, generateLintRulesIndexTs } from "./init-lexicon/templates/lint";
 import { generateLspCompletionsTs, generateLspHoverTs } from "./init-lexicon/templates/lsp";
-import { generatePackageJson, generateTsConfig, generateTsConfigBuild, generateJustfile, generateGitignore, generateReadme, generateSerializerTs, generateValidateTs, generateValidateCliTs } from "./init-lexicon/templates/project";
+import { generatePackageJson, generateTsConfig, generateTsConfigBuild, generateJustfile, generateGitignore, generateReadme, generateSerializerTs, generateValidateTs, generateValidateCliTs, generatePackageCliTs } from "./init-lexicon/templates/project";
 import { generatePluginTestTs, generateSerializerTestTs, generateCompletionsTestTs, generateHoverTestTs } from "./init-lexicon/templates/tests";
 import { generateDocsPackageJson, generateDocsTsConfig, generateDocsAstroConfig, generateDocsContentConfig, generateDocsIndexMdx, generateDocsGettingStartedMdx } from "./init-lexicon/templates/docs";
 import { generateExamplePackageJson, generateExampleInfraTs } from "./init-lexicon/templates/examples";
@@ -137,6 +137,7 @@ export async function initLexiconCommand(options: InitLexiconOptions): Promise<I
     "src/codegen/naming.ts": generateCodegenNamingTs(),
     "src/codegen/package.ts": generateCodegenPackageTs(name),
     "src/codegen/docs.ts": generateCodegenDocsTs(name),
+    "src/codegen/docs-cli.ts": generateCodegenDocsCliTs(),
     "src/spec/fetch.ts": generateSpecFetchTs(),
     "src/spec/parse.ts": generateSpecParseTs(),
     "src/lint/rules/sample.ts": generateSampleRuleTs(names),
@@ -149,6 +150,7 @@ export async function initLexiconCommand(options: InitLexiconOptions): Promise<I
     "src/serializer.test.ts": generateSerializerTestTs(name, names),
     "src/validate.ts": generateValidateTs(name),
     "src/validate-cli.ts": generateValidateCliTs(),
+    "src/package-cli.ts": generatePackageCliTs(),
     "package.json": generatePackageJson(name, names),
     "tsconfig.json": generateTsConfig(),
     "tsconfig.build.json": generateTsConfigBuild(),

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

@@ -348,5 +348,39 @@ describe("initCommand", () => {
       expect(pipeline).toContain("NodePipeline");
     });
   });
-});
 
+  // chant #2129 — core writes `chant.config.ts` before a plugin's root files
+  // and `writeIfNotExists` keeps the first one, so a template that ships its
+  // own config used to be discarded in silence. The template's wins now: it
+  // is the only one that knows the config namespace the scaffold needs.
+  test("a template's own chant.config.ts wins over the generic one", async () => {
+    await withTestDir(async (testDir) => {
+      const result = await initCommand({
+        path: testDir,
+        lexicon: "fountain",
+        template: "steward",
+        skipMcp: true,
+        skipInstall: true,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.createdFiles).toContain("chant.config.ts");
+      // Written once, so no "already exists, skipping" warning about it.
+      expect(result.warnings.filter((w) => w.includes("chant.config.ts"))).toEqual([]);
+
+      const config = readFileSync(join(testDir, "chant.config.ts"), "utf-8");
+      expect(config).toContain("fountain:");
+      expect(config).toContain('token: { env: "FOUNTAIN_TOKEN" }');
+      expect(result.createdFiles).toContain("src/prod-watch.op.ts");
+    });
+  });
+
+  test("a template without a config still gets the generic one", async () => {
+    await withTestDir(async (testDir) => {
+      await initCommand({ path: testDir, lexicon: "fountain", skipMcp: true, skipInstall: true });
+      const config = readFileSync(join(testDir, "chant.config.ts"), "utf-8");
+      expect(config).toContain('lexicons: ["fountain"]');
+      expect(config).not.toContain("profiles");
+    });
+  });
+});

package/src/cli/commands/init.ts

@@ -343,10 +343,17 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
     warnings,
   );
 
-  // Generate chant.config.ts
+  // Generate chant.config.ts. A template that ships its own wins: core's
+  // version knows only the lexicon name, while a template that declares a
+  // config namespace (fountain's steward scaffold and its `fountain.profiles`
+  // block, chant #2129) is scaffolding a project that needs it to run at all.
+  // The root-file loop below runs *after* this write, and `writeIfNotExists`
+  // keeps the first file, so a template's config would otherwise be discarded
+  // in silence — see lexicons/cedar/src/init-templates.ts, which documents
+  // having had to work around exactly that.
   writeIfNotExists(
     join(targetDir, "chant.config.ts"),
-    generateChantConfig(options.lexicon),
+    templateSet?.root?.["chant.config.ts"] ?? generateChantConfig(options.lexicon),
     "chant.config.ts",
     createdFiles,
     warnings,
@@ -372,9 +379,13 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
         warnings,
       );
     }
-    // Write root scaffold files (e.g. index.js, test.js, Dockerfile)
+    // Write root scaffold files (e.g. index.js, test.js, Dockerfile).
+    // `chant.config.ts` is skipped: it was already written above, from this
+    // same template set, and re-offering it here would only produce an
+    // "already exists, skipping" warning about a file the template supplied.
     if (templateSet.root) {
       for (const [filename, content] of Object.entries(templateSet.root)) {
+        if (filename === "chant.config.ts") continue;
         writeIfNotExists(
           join(targetDir, filename),
           content,

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

@@ -1,5 +1,6 @@
 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";
@@ -69,6 +70,54 @@ export const b = new Bucket({ encryption: { algo: "AES256" } });
     expect(result.diagnostics.some((d) => d.ruleId === "COR001")).toBe(true);
   });
 
+  // #2122 (epic #2114 sub-issue 6) — OPS013 is a core-owned Op-model
+  // post-synth check, run over every `*.op.ts` file `chant lint` finds under
+  // the target path with no lexicon or build needed. This is the acceptance
+  // criterion: it fires on a fixture with a dangling `stepOutput` reference,
+  // on a project with no lexicons configured (no `plugins` in `options`
+  // below, the same as every other test in this file).
+  test("OPS013 fires on a dangling stepOutput reference with no lexicons configured", async () => {
+    await writeFile(
+      join(testDir, "reconcile.op.ts"),
+      `
+export default {
+  [Symbol.for("chant.declarable")]: true,
+  entityType: "Chant::Op",
+  lexicon: "chant",
+  kind: "resource",
+  props: {
+    name: "reconcile",
+    overview: "test",
+    phases: [
+      { name: "Phase", steps: [
+        {
+          kind: "activity",
+          fn: "httpCheck",
+          args: {
+            url: "http://x",
+            contains: { [Symbol.for("chant.op.stepOutputRef")]: true, kind: "step-output-ref", step: "nope", path: "x" },
+          },
+        },
+      ] },
+    ],
+  },
+};
+      `,
+    );
+
+    const options: LintOptions = {
+      path: testDir,
+      format: "stylish",
+    };
+
+    const result = await lintCommand(options);
+
+    expect(result.success).toBe(false);
+    expect(
+      result.diagnostics.some((d) => d.ruleId === "OPS013" && d.message.includes('unknown step id "nope"')),
+    ).toBe(true);
+  });
+
   test("formats output as JSON", async () => {
     await writeFile(
       join(testDir, "nested.ts"),
@@ -493,3 +542,147 @@ 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);
+  });
+});