@intentius/chant 0.56.0 → 0.58.0

package/src/cli/commands/build.ts

@@ -14,11 +14,18 @@ import type { OwnershipMarker } from "../../ownership";
 import { resolveCliBuildParams } from "../build-params-cli";
 import type { Serializer, SerializerResult } from "../../serializer";
 import type { LexiconPlugin } from "../../lexicon";
-import { runPostSynthChecks } from "../../lint/post-synth";
+import { runPostSynthChecks, type PostSynthDiagnostic } from "../../lint/post-synth";
+import { loadActivityContracts } from "../../op/activity-contract-registry";
+import { isOpEntity } from "../../op/resource";
+import { serializeOpIR } from "../../op/op-ir";
+import type { OpConfig } from "../../op/types";
 import { coreReceiptChecks } from "../../lint/receipt-checks";
 import { coreOutputChecks } from "../../lint/output-checks";
 import { coreKnowledgeChecks } from "../../lint/knowledge-checks";
-import { applyConfiguredSeverity } from "../../lint/config";
+import { applyConfiguredSeverity, applyConfiguredPreset, resolvePresetIds } from "../../lint/config";
+import { applyInlineSuppressions, type SuppressionMetaFinding } from "../../lint/suppressions";
+import type { Declarable } from "../../declarable";
+import { coreOpChecks } from "../../lint/rules/op";
 import { loadPolicyChecks } from "../../lint/policy";
 import { armSandboxPolicyExecution, runProjectPolicies } from "../../lint/policy-sandbox";
 import { sortedJsonReplacer } from "../../utils";
@@ -392,7 +399,46 @@ export async function buildCommand(options: BuildOptions): Promise<BuildResult>
   // rule id — so `lint.rules: { WAW019: "off" }` suppresses a post-synth
   // finding just as it suppresses a pre-synth one. A finding it suppresses is
   // counted, not dropped silently — see `suppressedPostSynthCount` below.
+  //
+  // chant #2111: every batch also goes through `applyInlineSuppressions`
+  // right after, so a `# chant-ignore` comment on an entity (terraform's HCL
+  // blocks today; any lexicon that attaches `suppressions` to its own
+  // entities tomorrow) suppresses identically regardless of which phase
+  // produced the diagnostic. Same counted-not-dropped contract, in its own
+  // `inlineSuppressedCount`, plus `suppressionMeta` for directives that are
+  // themselves worth a finding (expired, misplaced, denied by `ignorable: false`).
   let suppressedPostSynthCount = 0;
+  let inlineSuppressedCount = 0;
+  const suppressionMeta: SuppressionMetaFinding[] = [];
+  // A rule a `lint.presets` preset excludes (chant #2113) is a distinct
+  // reason a finding doesn't reach the errors/warnings lists. The preset
+  // decided the rule shouldn't run at all under this project's configured
+  // tier, not that `lint.rules` downgraded it to "off", so it gets its own
+  // counter and its own summary line rather than folding into the one above.
+  let suppressedPresetCount = 0;
+
+  /**
+   * Apply every suppression/filtering surface to one batch, in order:
+   * `lint.presets` (chant #2113, which check ids are enabled at all; a
+   * no-op when `presetIds` is undefined, the case for every call site below
+   * except the per-plugin loop, which is the only one with a lexicon a
+   * preset could apply to), then `lint.rules` severity overrides (chant
+   * #1138), then inline `# chant-ignore` comments (chant #2111).
+   */
+  const resolvePostSynth = (
+    diags: PostSynthDiagnostic[],
+    entities: Map<string, Declarable>,
+    presetIds?: Set<string>,
+  ): PostSynthDiagnostic[] => {
+    const { diagnostics: afterPreset, suppressed: presetSuppressed } = applyConfiguredPreset(diags, presetIds, config.lint?.rules);
+    suppressedPresetCount += presetSuppressed.length;
+    const { diagnostics: afterConfig, suppressed: configSuppressed } = applyConfiguredSeverity(afterPreset, config.lint?.rules);
+    suppressedPostSynthCount += configSuppressed.length;
+    const { diagnostics: active, suppressed: inlineSuppressed, meta } = applyInlineSuppressions(afterConfig, entities, config.lint?.rules);
+    inlineSuppressedCount += inlineSuppressed.length;
+    suppressionMeta.push(...meta);
+    return active;
+  };
 
   // Core-owned post-synth checks over effect receipts (#1833). Receipts are
   // recognized by marker, lexicon-independently, so this set runs over the
@@ -400,9 +446,7 @@ export async function buildCommand(options: BuildOptions): Promise<BuildResult>
   // Same severity-resolution funnel as every other post-synth finding.
   if (result.errors.length === 0) {
     const receiptDiags = runPostSynthChecks(coreReceiptChecks(), result, env);
-    const { diagnostics: activeDiags, suppressed } = applyConfiguredSeverity(receiptDiags, config.lint?.rules);
-    suppressedPostSynthCount += suppressed.length;
-    for (const diag of activeDiags) {
+    for (const diag of resolvePostSynth(receiptDiags, result.entities)) {
       const prefix = diag.entity ? `[${diag.entity}] ` : "";
       const lexiconSuffix = diag.lexicon ? ` (${diag.lexicon})` : "";
       if (diag.severity === "error") {
@@ -419,9 +463,7 @@ export async function buildCommand(options: BuildOptions): Promise<BuildResult>
   // the FULL build result the same way the receipt checks above do.
   if (result.errors.length === 0) {
     const outputDiags = runPostSynthChecks(coreOutputChecks(), result, env);
-    const { diagnostics: activeDiags, suppressed } = applyConfiguredSeverity(outputDiags, config.lint?.rules);
-    suppressedPostSynthCount += suppressed.length;
-    for (const diag of activeDiags) {
+    for (const diag of resolvePostSynth(outputDiags, result.entities)) {
       const prefix = diag.entity ? `[${diag.entity}] ` : "";
       const lexiconSuffix = diag.lexicon ? ` (${diag.lexicon})` : "";
       if (diag.severity === "error") {
@@ -440,7 +482,36 @@ export async function buildCommand(options: BuildOptions): Promise<BuildResult>
   if (result.errors.length === 0) {
     const bundle = await loadOkfBundle(resolveKnowledgeDir(config, configDir));
     const knowledgeDiags = runPostSynthChecks(coreKnowledgeChecks(bundle), result, env);
-    const { diagnostics: activeDiags, suppressed } = applyConfiguredSeverity(knowledgeDiags, config.lint?.rules);
+    for (const diag of resolvePostSynth(knowledgeDiags, result.entities)) {
+      const prefix = diag.entity ? `[${diag.entity}] ` : "";
+      const lexiconSuffix = diag.lexicon ? ` (${diag.lexicon})` : "";
+      if (diag.severity === "error") {
+        errors.push(formatError({ message: `${prefix}${diag.message}${lexiconSuffix}` }));
+      } else {
+        warnings.push(formatWarning({ message: `${prefix}${diag.message}${lexiconSuffix}` }));
+      }
+    }
+  }
+
+  // Activity contracts across every loaded lexicon (chant #2101): core's own
+  // plus each lexicon's, by the same `@intentius/chant-lexicon-<name>/op/...`
+  // convention `loadActivities` resolves implementations with. OPS012/OPS013
+  // and a plugin's own checks merge this over their own tables, so a step
+  // calling a lexicon's activity is validated against that lexicon's contract
+  // instead of failing for the absence of one. Resolved once, for both check
+  // passes below.
+  const activityContracts =
+    result.errors.length === 0 ? await loadActivityContracts(options.plugins ?? []) : undefined;
+
+  // Core-owned post-synth checks over the Op model (#2122, epic #2114
+  // sub-issue 6) — OPS012/OPS013/OPS014, ported from a hosting lexicon's
+  // own TMP012/TMP013/TMP014. An Op is recognized by entity type
+  // (`OpResource`), not by which lexicon declared it, so this runs over the
+  // FULL build result regardless of which plugins loaded — same as the
+  // receipt/output/knowledge checks above.
+  if (result.errors.length === 0) {
+    const opDiags = runPostSynthChecks(coreOpChecks(), result, env, { activityContracts });
+    const { diagnostics: activeDiags, suppressed } = applyConfiguredSeverity(opDiags, config.lint?.rules);
     suppressedPostSynthCount += suppressed.length;
     for (const diag of activeDiags) {
       const prefix = diag.entity ? `[${diag.entity}] ` : "";
@@ -471,10 +542,16 @@ export async function buildCommand(options: BuildOptions): Promise<BuildResult>
       }
 
       const scopedResult = { ...result, outputs: scopedOutputs };
-      const postDiags = runPostSynthChecks(checks, scopedResult, env);
-      const { diagnostics: activeDiags, suppressed } = applyConfiguredSeverity(postDiags, config.lint?.rules);
-      suppressedPostSynthCount += suppressed.length;
-      for (const diag of activeDiags) {
+      const postDiags = runPostSynthChecks(checks, scopedResult, env, { activityContracts });
+      // `lint.presets` (chant #2113) filters WHICH check ids are reported at
+      // all, before `lint.rules`/inline suppression act on the reported
+      // ones. It's a no-op for a lexicon that ships no `lintPresets()` (the
+      // common case today), since `resolvePresetIds` returns `undefined`
+      // for one. This is the only `resolvePostSynth` call site with a
+      // lexicon a preset could apply to; every other call below passes no
+      // `presetIds` at all.
+      const presetIds = resolvePresetIds(plugin.lintPresets?.(), config.lint?.presets?.[plugin.name] ?? "recommended");
+      for (const diag of resolvePostSynth(postDiags, result.entities, presetIds)) {
         const prefix = diag.entity ? `[${diag.entity}] ` : "";
         const lexiconSuffix = diag.lexicon ? ` (${diag.lexicon})` : "";
         if (diag.severity === "error") {
@@ -511,9 +588,7 @@ export async function buildCommand(options: BuildOptions): Promise<BuildResult>
         env,
         preloaded: preloadedPolicyChecks,
       });
-      const { diagnostics: activePolicyDiags, suppressed } = applyConfiguredSeverity(policyDiags, config.lint?.rules);
-      suppressedPostSynthCount += suppressed.length;
-      for (const diag of activePolicyDiags) {
+      for (const diag of resolvePostSynth(policyDiags, result.entities)) {
         const prefix = diag.entity ? `[${diag.entity}] ` : "";
         const where = diag.lexicon ? ` (${diag.lexicon})` : "";
         const msg = `[policy:${diag.checkId}] ${prefix}${diag.message}${where}`;
@@ -529,15 +604,45 @@ export async function buildCommand(options: BuildOptions): Promise<BuildResult>
         }),
       );
     }
+
+    if (suppressedPresetCount > 0) {
+      warnings.push(
+        formatWarning({
+          message: `${suppressedPresetCount} post-synth finding(s) not reported: excluded by the active lint.presets preset`,
+        }),
+      );
+    }
+
+    if (inlineSuppressedCount > 0) {
+      warnings.push(
+        formatWarning({
+          message: `${inlineSuppressedCount} post-synth finding(s) suppressed via inline chant-ignore comments`,
+        }),
+      );
+    }
+
+    // Directives that are themselves worth a finding (expired, misplaced, or
+    // naming a rule id configured `ignorable: false`) are reported once
+    // each, never silently (chant #2111).
+    for (const m of suppressionMeta) {
+      warnings.push(formatWarning({ message: `[${m.checkId}] ${m.file}:${m.line} ${m.message}` }));
+    }
   }
 
   // Empty-output guard: source files were discovered but no lexicon produced
   // any output. Almost always indicates broken imports resolving to undefined
   // (e.g. missing root re-exports from a lexicon) or modules that exported no
   // Declarables. Without this guard, chant writes "{}" and exits 0.
+  //
+  // An Op declaration is the honest exception (#2118): it belongs to no
+  // lexicon partition and its build output is the `op.json` written below,
+  // not a resource manifest, so an Ops-only project legitimately produces no
+  // serializer output and must not be reported as a broken import.
+  const declaredOps = [...result.entities.values()].filter(isOpEntity);
   if (
     result.sourceFileCount > 0 &&
     result.outputs.size === 0 &&
+    declaredOps.length === 0 &&
     result.errors.length === 0 &&
     errors.length === 0
   ) {
@@ -658,12 +763,12 @@ export async function buildCommand(options: BuildOptions): Promise<BuildResult>
       }
     }
 
-    // Op worker artifacts (`ops/<name>/{workflow,worker,activities}.ts`) always
-    // go to `<project>/dist/ops/` — the fixed location `chant run <op> --temporal`
-    // reads (`join(projectPath, "dist", "ops", ...)`) — independent of `--output`,
-    // which routes the primary resource manifest. Without this, a bare `chant build`
-    // only printed them to stderr and `--output foo.yaml` scattered them next to
-    // `foo.yaml`, so the durable-run worker was never where `run --temporal` looks.
+    // Anything a serializer emits under `ops/` always goes to
+    // `<project>/dist/ops/` — the fixed place an Op's build output is read
+    // from, alongside the `op.json` core writes below — independent of
+    // `--output`, which routes the primary resource manifest. Without this, a
+    // bare `chant build` only printed them to stderr and `--output foo.yaml`
+    // scattered them next to `foo.yaml`.
     const projectDist = resolve(options.path ?? ".", "dist");
     let opsWritten = 0;
     for (const [filename, entry] of [...additionalFiles]) {
@@ -677,13 +782,40 @@ export async function buildCommand(options: BuildOptions): Promise<BuildResult>
       } catch (err) {
         errors.push(
           formatError({
-            message: `Failed to write Op worker file ${filename}: ${err instanceof Error ? err.message : String(err)}`,
+            message: `Failed to write Op output file ${filename}: ${err instanceof Error ? err.message : String(err)}`,
           }),
         );
       }
     }
     if (opsWritten > 0) {
-      console.error(formatInfo(`Wrote ${opsWritten} Op worker file(s) under ${join(options.path ?? ".", "dist", "ops")}/`));
+      console.error(formatInfo(`Wrote ${opsWritten} Op output file(s) under ${join(options.path ?? ".", "dist", "ops")}/`));
+    }
+
+    // `dist/ops/<name>/op.json` — the Op IR (#1289), written here by core
+    // rather than emitted by a lexicon serializer (#2118). An Op declaration
+    // is core's own entity now (`Chant::Op`, lexicon `chant`) and is held out
+    // of `partitionByLexicon` entirely, so this is the one place its build
+    // output is produced: a deterministic, engine-neutral restatement of the
+    // step graph that anything can read without importing chant.
+    let irWritten = 0;
+    for (const entity of declaredOps) {
+      const config = (entity as unknown as { props?: OpConfig }).props;
+      if (!config?.name) continue;
+      try {
+        const targetPath = join(projectDist, "ops", config.name, "op.json");
+        mkdirSync(dirname(targetPath), { recursive: true });
+        writeFileSync(targetPath, serializeOpIR(config));
+        irWritten += 1;
+      } catch (err) {
+        errors.push(
+          formatError({
+            message: `Failed to write op.json for Op "${config.name}": ${err instanceof Error ? err.message : String(err)}`,
+          }),
+        );
+      }
+    }
+    if (irWritten > 0) {
+      console.error(formatInfo(`Wrote ${irWritten} op.json file(s) under ${join(options.path ?? ".", "dist", "ops")}/`));
     }
 
     if (options.output) {

package/src/cli/commands/check-lexicon-docs.ts

@@ -4,7 +4,7 @@
  * The contract used to check documentation by counting files — "at least 1
  * .mdx page" at tier 1, "at least 8" at tier 2 — and never opened one. That
  * counts a page nothing links to exactly the same as a page a reader can
- * actually find, so azure, temporal, helm and github each accumulated
+ * actually find, so azure, helm and github each accumulated
  * hand-added pages that appear in no sidebar and are reachable only by typing
  * their URL. Azure's getting-started, resource reference and composites pages
  * were all invisible while its ≥8-page check passed comfortably — the count

package/src/cli/commands/check-lexicon-examples.test.ts

@@ -119,7 +119,7 @@ export const plainBucket = new Bucket({
     const results = await checkExamplesBuild(dir);
     const insecure = results.find((r) => r.example === "insecure");
     expect(insecure?.ok).toBe(false);
-    expect(insecure?.detail).toMatch(/post-synth error\(s\) from the lexicon's own checks/);
+    expect(insecure?.detail).toMatch(/post-synth error\(s\)/);
     expect(insecure?.detail).toMatch(/WAW042: \[plainBucket\]/);
   });
 
@@ -141,6 +141,34 @@ export const plainBucket = new Bucket({
     expect(results.find((r) => r.example === "suppressed")).toMatchObject({ ok: true });
   });
 
+  // #2101 — the third axis: core's own Op-model checks run over the example's
+  // result too, so an example carrying an Op has it validated here rather
+  // than only when a user builds the example themselves. The Op below
+  // references a step whose activity has no registered contract anywhere,
+  // which is exactly what OPS013 exists to refuse.
+  test("an example whose Op fails core's own OPS checks fails (#2101)", async () => {
+    writeLexiconDirWithExample(dir, "bad-op", {
+      "bucket.ts": cleanBucketSource,
+      "broken.op.ts": `import { Op, phase, activity, stepOutput } from "@intentius/chant/op";
+
+export const brokenOp = Op({
+  name: "broken",
+  overview: "references a step nothing declares",
+  phases: [
+    phase("Run", [
+      activity("shellCmd", { cmd: stepOutput("nope", "value") }),
+    ]),
+  ],
+});
+`,
+    });
+
+    const results = await checkExamplesBuild(dir);
+    const badOp = results.find((r) => r.example === "bad-op");
+    expect(badOp?.ok).toBe(false);
+    expect(badOp?.detail).toMatch(/OPS013/);
+  });
+
   test("an empty src/ directory is skipped, not reported as a failure", async () => {
     writeLexiconDirWithExample(dir, "empty", {});
     const results = await checkExamplesBuild(dir);

package/src/cli/commands/check-lexicon-examples.ts

@@ -23,6 +23,14 @@
  * diagnostic left at `error` severity fails the example. Warnings do not.
  * An example is what a user copies wholesale; it must not teach a pattern
  * the lexicon it demonstrates flags as an error.
+ *
+ * #2101 added the third axis: core's own Op-model checks (OPS012/OPS013/
+ * OPS014, `../../lint/rules/op/`) run over the same result, as `chant build`
+ * runs them, so an example carrying an Op has that Op validated here rather
+ * than only when a user builds the example themselves. They are given the
+ * activity contracts every loaded lexicon declares, resolved the same way
+ * `chant build` resolves them, so a step calling that lexicon's own activity
+ * validates against its own schemas.
  */
 
 import { existsSync, readdirSync } from "fs";
@@ -31,8 +39,11 @@ import { build, type BuildResult } from "../../build";
 import { findInfraFiles } from "../../discovery/files";
 import { detectLexicons } from "../../detectLexicon";
 import { loadChantConfig } from "../../config";
-import { loadPlugins } from "../plugins";
+import { loadPlugins, collectBuildRootContributors } from "../plugins";
 import { runPostSynthChecks, type PostSynthDiagnostic } from "../../lint/post-synth";
+import { coreOpChecks } from "../../lint/rules/op";
+import { loadActivityContracts } from "../../op/activity-contract-registry";
+import type { ActivityContract } from "../../op/activity-contract";
 import { applyConfiguredSeverity } from "../../lint/config";
 import type { LexiconPlugin } from "../../lexicon";
 import type { SerializerResult } from "../../serializer";
@@ -44,18 +55,31 @@ export interface ExampleBuildResult {
 }
 
 /**
- * Run each plugin's own post-synth checks against that plugin's output —
- * the same per-plugin scoping and `lint.rules` severity resolution
- * `cli/commands/build.ts` applies — and return what is left at `error`
- * severity. Project `lint.policies` are not run here: those are the
- * example author's organizational policy, not the lexicon's contract.
+ * Run core's Op-model checks over the whole result, then each plugin's own
+ * post-synth checks against that plugin's output — the same scoping and
+ * `lint.rules` severity resolution `cli/commands/build.ts` applies — and
+ * return what is left at `error` severity. Project `lint.policies` are not
+ * run here: those are the example author's organizational policy, not the
+ * lexicon's contract.
  */
 export function postSynthErrors(
   plugins: LexiconPlugin[],
   result: BuildResult,
   lintRules: Parameters<typeof applyConfiguredSeverity>[1],
+  activityContracts?: ReadonlyMap<string, ActivityContract>,
 ): PostSynthDiagnostic[] {
   const errors: PostSynthDiagnostic[] = [];
+
+  // Core's Op-model checks first (#2101). An Op is recognized by entity type,
+  // not by which lexicon declared it, so these run over the FULL result the
+  // way `chant build` runs them — unscoped, and regardless of which plugins
+  // loaded. Without this an example's Op reached output unvalidated, which is
+  // why the terraform, aws and render examples kept their Ops outside `src/`.
+  const opDiags = runPostSynthChecks(coreOpChecks(), result, undefined, { activityContracts });
+  for (const diag of applyConfiguredSeverity(opDiags, lintRules).diagnostics) {
+    if (diag.severity === "error") errors.push(diag);
+  }
+
   for (const plugin of plugins) {
     if (!plugin.postSynthChecks) continue;
     const checks = plugin.postSynthChecks();
@@ -66,7 +90,7 @@ export function postSynthErrors(
     const pluginOutput = result.outputs.get(outputKey);
     if (pluginOutput !== undefined) scopedOutputs.set(outputKey, pluginOutput);
 
-    const diags = runPostSynthChecks(checks, { ...result, outputs: scopedOutputs });
+    const diags = runPostSynthChecks(checks, { ...result, outputs: scopedOutputs }, undefined, { activityContracts });
     const { diagnostics } = applyConfiguredSeverity(diags, lintRules);
     for (const diag of diagnostics) {
       if (diag.severity === "error") errors.push(diag);
@@ -129,7 +153,15 @@ export async function checkExamplesBuild(lexiconDir: string): Promise<ExampleBui
       }
 
       const plugins = await loadPlugins(lexiconNames);
-      const result = await build(srcDir, plugins.map((p) => p.serializer));
+      // Bind each plugin's `buildRoots()` hook exactly as `chant build` does
+      // (#2083): a lexicon whose entities come from config-declared roots
+      // rather than typed source (k8s kustomize roots, terraform roots) has
+      // nothing to serialize otherwise, and its example would read as
+      // "produced no output" for a reason that is this harness's, not the
+      // example's.
+      const exampleDir = join(examplesDir, entry.name);
+      const buildRoots = collectBuildRootContributors(plugins, exampleConfig as Record<string, unknown>, exampleDir);
+      const result = await build(srcDir, plugins.map((p) => p.serializer), undefined, { buildRoots });
 
       const structuralErrors = result.errors.map((e) => e.message);
       const producedOutput = result.outputs.size > 0;
@@ -139,7 +171,7 @@ export async function checkExamplesBuild(lexiconDir: string): Promise<ExampleBui
       // already explains the failure, and partial output is not the output
       // the checks are meant to see.
       const postSynth = structurallyOk
-        ? postSynthErrors(plugins, result, exampleConfig.lint?.rules)
+        ? postSynthErrors(plugins, result, exampleConfig.lint?.rules, await loadActivityContracts(plugins))
         : [];
       const ok = structurallyOk && postSynth.length === 0;
 
@@ -152,7 +184,7 @@ export async function checkExamplesBuild(lexiconDir: string): Promise<ExampleBui
             ? structuralErrors.join("; ")
             : !producedOutput
               ? "discovered source but produced no output"
-              : `post-synth error(s) from the lexicon's own checks: ${postSynth.map(formatPostSynthError).join("; ")}`,
+              : `post-synth error(s): ${postSynth.map(formatPostSynthError).join("; ")}`,
       });
     } catch (err) {
       results.push({

package/src/cli/commands/import.ts

@@ -313,6 +313,12 @@ function parseAndWrite(
     };
   }
 
+  // Sections the parser read but import cannot carry, named by the parser
+  // rather than dropped silently (#2069).
+  if (ir.warnings) {
+    warnings.push(...ir.warnings);
+  }
+
   const generator = plugin.templateGenerator!();
 
   // Check output directory

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

@@ -150,6 +150,7 @@ export async function packageLexicon(options?: { verbose?: boolean; force?: bool
     buildManifest: (genResult) => ({
       name: "${name}",
       version: "0.0.1",
+      chantVersion: ">=0.1.0",
     }),
     srcDir,
     collectSkills: () => new Map(),
@@ -161,6 +162,14 @@ export async function packageLexicon(options?: { verbose?: boolean; force?: bool
 `;
 }
 
+export function generateCodegenDocsCliTs(): string {
+  return `#!/usr/bin/env tsx
+import { generateDocs } from "./docs";
+
+await generateDocs({ verbose: true });
+`;
+}
+
 export function generateCodegenDocsTs(name: string): string {
   return `import { docsPipeline, writeDocsSite } from "@intentius/chant/codegen/docs";
 

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

@@ -10,8 +10,16 @@ export function generatePackageJson(name: string, names: { packageName: string }
     private: true,
     files: ["src/", "dist/"],
     exports: {
-      ".": "./src/index.ts",
-      "./*": "./src/*",
+      ".": {
+        development: "./src/index.ts",
+        types: "./dist/index.d.ts",
+        default: "./src/index.ts",
+      },
+      "./*": {
+        development: "./src/*.ts",
+        types: "./dist/*.d.ts",
+        default: "./src/*.ts",
+      },
       "./manifest": "./dist/manifest.json",
       "./meta": "./dist/meta.json",
       "./types": "./dist/types/index.d.ts",
@@ -20,8 +28,9 @@ export function generatePackageJson(name: string, names: { packageName: string }
       generate: "npx tsx src/codegen/generate-cli.ts",
       validate: "npx tsx src/validate-cli.ts",
       docs: "npx tsx src/codegen/docs-cli.ts",
-      build: "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
-      prepack: "npm run generate && npm run validate && npm run build",
+      build: 'tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json && find dist -type f \\( -name "*.js" -o -name "*.js.map" \\) -delete',
+      prepack: "npm run generate && npm run bundle && npm run validate && npm run build",
+      bundle: "tsx src/package-cli.ts",
     },
     devDependencies: {
       // `*` (not `workspace:*`) so a fresh lexicon `npm install`s under plain npm
@@ -211,3 +220,34 @@ import { validate } from "./validate";
 await validate();
 `;
 }
+
+/**
+ * Thin entry point for `npm run bundle`, called from `prepack`. Writes
+ * `src/generated/` (via the generate pipeline) and `dist/` (via the package
+ * pipeline plus `writeBundleSpec`), so `dist/manifest.json` exists before
+ * `npm run validate` and `npm run build` run.
+ */
+export function generatePackageCliTs(): string {
+  return `#!/usr/bin/env tsx
+import { generate, writeGeneratedFiles } from "./codegen/generate";
+import { packageLexicon } from "./codegen/package";
+import { writeBundleSpec } from "@intentius/chant/codegen/package";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const srcDir = dirname(fileURLToPath(import.meta.url));
+
+// 1. Generate src/generated/ files (writeGeneratedFiles resolves its own target)
+const genResult = await generate({ verbose: true });
+writeGeneratedFiles(genResult);
+
+// 2. Run package pipeline and write dist/
+const { spec, stats } = await packageLexicon({ verbose: true });
+
+const distDir = join(dirname(srcDir), "dist");
+writeBundleSpec(spec, distDir);
+
+console.error(\`Packaged \${stats.resources} resources, \${stats.ruleCount} rules, \${stats.skillCount} skills\`);
+console.error(\`dist/ written to \${distDir}\`);
+`;
+}