@intentius/chant 0.0.4 → 0.0.5

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

@@ -22,14 +22,13 @@ describe("initCommand", () => {
       expect(result.createdFiles).toContain("tsconfig.json");
       expect(result.createdFiles).toContain("chant.config.ts");
       expect(result.createdFiles).toContain(".gitignore");
-      expect(result.createdFiles).toContain("src/_.ts");
       expect(result.createdFiles).toContain("src/config.ts");
       expect(result.createdFiles).toContain("src/data-bucket.ts");
       expect(result.createdFiles).toContain("src/logs-bucket.ts");
     });
   });
 
-  test("aws source files use namespace imports", async () => {
+  test("aws source files use direct imports", async () => {
     await withTestDir(async (testDir) => {
       const options: InitOptions = {
         path: testDir,
@@ -41,15 +40,15 @@ describe("initCommand", () => {
       await initCommand(options);
 
       const configContent = readFileSync(join(testDir, "src", "config.ts"), "utf-8");
-      expect(configContent).toContain('import * as aws from "@intentius/chant-lexicon-aws"');
+      expect(configContent).toContain('from "@intentius/chant-lexicon-aws"');
 
       const dataBucketContent = readFileSync(join(testDir, "src", "data-bucket.ts"), "utf-8");
-      expect(dataBucketContent).toContain('import * as aws from "@intentius/chant-lexicon-aws"');
-      expect(dataBucketContent).toContain('import * as _ from "./_"');
+      expect(dataBucketContent).toContain('from "@intentius/chant-lexicon-aws"');
+      expect(dataBucketContent).toContain('from "./config"');
 
       const logsBucketContent = readFileSync(join(testDir, "src", "logs-bucket.ts"), "utf-8");
-      expect(logsBucketContent).toContain('import * as aws from "@intentius/chant-lexicon-aws"');
-      expect(logsBucketContent).toContain('import * as _ from "./_"');
+      expect(logsBucketContent).toContain('from "@intentius/chant-lexicon-aws"');
+      expect(logsBucketContent).toContain('from "./config"');
     });
   });
 
@@ -177,7 +176,7 @@ describe("initCommand", () => {
     });
   });
 
-  test("generates barrel file", async () => {
+  test("does not generate barrel file", async () => {
     await withTestDir(async (testDir) => {
       const options: InitOptions = {
         path: testDir,
@@ -188,13 +187,11 @@ describe("initCommand", () => {
 
       await initCommand(options);
 
+      // No _.ts barrel — direct imports are used instead
       const barrelPath = join(testDir, "src", "_.ts");
-      expect(existsSync(barrelPath)).toBe(true);
+      expect(existsSync(barrelPath)).toBe(false);
 
-      const barrelContent = readFileSync(barrelPath, "utf-8");
-      expect(barrelContent).toContain('export * from "./config"');
-
-      // No index.ts — barrel re-exports cause duplicate entity errors during build
+      // No index.ts either
       const indexPath = join(testDir, "src", "index.ts");
       expect(existsSync(indexPath)).toBe(false);
     });
@@ -218,7 +215,6 @@ describe("initCommand", () => {
       expect(coreContent).toContain("Value<T>");
       expect(coreContent).toContain("Serializer");
       expect(coreContent).toContain("ChantConfig");
-      expect(coreContent).toContain("barrel");
 
       const corePkg = join(testDir, ".chant", "types", "core", "package.json");
       expect(existsSync(corePkg)).toBe(true);

package/src/cli/commands/init.ts

@@ -214,8 +214,6 @@ export interface ChantConfig {
   };
 }
 
-/** Barrel proxy — lazy-loads all sibling exports */
-export declare function barrel(dir: string): Record<string, unknown>;
 `;
 }
 
@@ -345,7 +343,7 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
     warnings,
   );
 
-  // Generate source files from plugin (or fallback to a minimal barrel)
+  // Generate source files from plugin (if available)
   let sourceFiles: Record<string, string> = {};
   try {
     const plugin = await loadPlugin(options.lexicon);
@@ -353,10 +351,7 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
       sourceFiles = plugin.initTemplates();
     }
   } catch {
-    // Plugin not yet installed — write a minimal barrel stub
-    sourceFiles = {
-      "_.ts": "// Barrel — re-export shared config here\n",
-    };
+    // Plugin not yet installed — no source files to scaffold
   }
   for (const [filename, content] of Object.entries(sourceFiles)) {
     writeIfNotExists(

package/src/cli/commands/lint.ts

@@ -1,7 +1,7 @@
 import { resolve, join } from "path";
 import { readFileSync, writeFileSync, readdirSync, statSync } from "fs";
 import { runLint } from "../../lint/engine";
-import type { LintRule, LintDiagnostic, LintFix, LintRunOptions } from "../../lint/rule";
+import type { LintRule, LintDiagnostic, LintFix } from "../../lint/rule";
 import { loadPlugins, resolveProjectLexicons } from "../plugins";
 import { formatStylish, formatJson, formatSarif } from "../reporters/stylish";
 import { loadLocalRules } from "../../lint/rule-loader";
@@ -241,54 +241,30 @@ export async function lintCommand(options: LintOptions): Promise<LintResult> {
   // Get all TypeScript files
   const files = getTypeScriptFiles(infraPath);
 
-  // Build barrel exports context for EVL008
-  let runOptions: LintRunOptions | undefined;
-  try {
-    const { scanProject } = require("../../project/scan");
-    const scan = scanProject(infraPath);
-    const barrelExports = new Set<string>(scan.exports.map((e: { name: string }) => e.name));
-    const projectExports = new Map<string, { file: string; className: string }>();
-    for (const exp of scan.exports) {
-      projectExports.set(exp.name, { file: exp.file, className: exp.className });
-    }
-    runOptions = { barrelExports, projectExports, projectScan: scan };
-  } catch {
-    // No barrel file found — EVL008/COR016 will be no-ops
-  }
-
   // Run lint — use per-file rules when overrides are present
   let diagnostics: LintDiagnostic[];
   if (options.rules) {
-    diagnostics = await runLint(files, options.rules, undefined, runOptions);
+    diagnostics = await runLint(files, options.rules, undefined);
   } else if (hasOverrides) {
     diagnostics = [];
     for (const file of files) {
       const relativePath = file.slice(infraPath.length + 1);
       const { rules: fileRules, ruleOptions } = getDefaultRules(infraPath, relativePath, allRules);
-      const fileDiagnostics = await runLint([file], fileRules, ruleOptions, runOptions);
+      const fileDiagnostics = await runLint([file], fileRules, ruleOptions);
       diagnostics.push(...fileDiagnostics);
     }
   } else {
     const { rules, ruleOptions } = getDefaultRules(infraPath, undefined, allRules);
-    diagnostics = await runLint(files, rules, ruleOptions, runOptions);
+    diagnostics = await runLint(files, rules, ruleOptions);
   }
 
   // Apply fixes if requested
   if (options.fix) {
-    // Handle cross-file write fixes (COR016) separately
-    for (const diag of diagnostics) {
-      if (diag.fix?.kind === "write-file" && diag.fix.params) {
-        const path = diag.fix.params.path as string;
-        const content = diag.fix.params.content as string;
-        writeFileSync(path, content, "utf-8");
-      }
-    }
-
-    // Group remaining fixes by file (exclude write-file fixes)
+    // Group fixes by file
     const fixesByFile = new Map<string, LintFix[]>();
 
     for (const diag of diagnostics) {
-      if (diag.fix && diag.fix.kind !== "write-file") {
+      if (diag.fix) {
         const existing = fixesByFile.get(diag.file) ?? [];
         existing.push(diag.fix);
         fixesByFile.set(diag.file, existing);
@@ -303,18 +279,18 @@ export async function lintCommand(options: LintOptions): Promise<LintResult> {
     // Re-lint after fixes to get updated diagnostics
     let postFixDiagnostics: LintDiagnostic[];
     if (options.rules) {
-      postFixDiagnostics = await runLint(files, options.rules, undefined, runOptions);
+      postFixDiagnostics = await runLint(files, options.rules, undefined);
     } else if (hasOverrides) {
       postFixDiagnostics = [];
       for (const file of files) {
         const relativePath = file.slice(infraPath.length + 1);
         const { rules: fileRules, ruleOptions } = getDefaultRules(infraPath, relativePath, allRules);
-        const fileDiagnostics = await runLint([file], fileRules, ruleOptions, runOptions);
+        const fileDiagnostics = await runLint([file], fileRules, ruleOptions);
         postFixDiagnostics.push(...fileDiagnostics);
       }
     } else {
       const { rules, ruleOptions } = getDefaultRules(infraPath, undefined, allRules);
-      postFixDiagnostics = await runLint(files, rules, ruleOptions, runOptions);
+      postFixDiagnostics = await runLint(files, rules, ruleOptions);
     }
     diagnostics.length = 0;
     diagnostics.push(...postFixDiagnostics);

package/src/cli/main.ts

@@ -161,7 +161,7 @@ const registry: CommandDef[] = [
   { name: "import", handler: runImport },
   { name: "init", handler: runInit },
   { name: "init lexicon", handler: runInitLexicon },
-  { name: "update", handler: runUpdate },
+{ name: "update", handler: runUpdate },
   { name: "doctor", handler: runDoctor },
 
   // Dev subcommands

package/src/codegen/docs-interpolation.test.ts

@@ -12,7 +12,7 @@ describe("expandFileMarkers", () => {
     mkdirSync(join(dir, "sub"), { recursive: true });
     writeFileSync(
       join(dir, "example.ts"),
-      'import * as _ from "./_";\n\nexport const bucket = new _.Bucket({\n  bucketName: "test",\n});\n',
+      'import { Bucket } from "@intentius/chant-lexicon-aws";\n\nexport const bucket = new Bucket({\n  bucketName: "test",\n});\n',
     );
     writeFileSync(
       join(dir, "sub", "nested.ts"),
@@ -27,7 +27,7 @@ describe("expandFileMarkers", () => {
   test("expands full file marker", () => {
     const result = expandFileMarkers("Before\n\n{{file:example.ts}}\n\nAfter", dir);
     expect(result).toContain('```typescript title="example.ts"');
-    expect(result).toContain('import * as _ from "./_";');
+    expect(result).toContain('import { Bucket } from "@intentius/chant-lexicon-aws";');
     expect(result).toContain("```");
     expect(result).toStartWith("Before\n\n");
     expect(result).toEndWith("\n\nAfter");

package/src/codegen/docs.ts

@@ -190,10 +190,11 @@ export function docsPipeline(config: DocsConfig): DocsResult {
   // Generate pages
   const pages = new Map<string, string>();
 
-  pages.set(
-    "index.mdx",
-    generateOverview(config, manifest, resources, properties, serviceGroups, rules),
-  );
+  let overviewContent = generateOverview(config, manifest, resources, properties, serviceGroups, rules);
+  if (config.examplesDir) {
+    overviewContent = expandFileMarkers(overviewContent, config.examplesDir);
+  }
+  pages.set("index.mdx", overviewContent);
   const suppress = new Set(config.suppressPages ?? []);
 
   // Extra pages from lexicon config

package/src/codegen/generate-registry.test.ts

@@ -69,7 +69,7 @@ describe("buildRegistry", () => {
         typeName: "Test::S3::Bucket",
         attributes: [],
         properties: [],
-        propertyTypes: [{ name: "Bucket_Versioning", cfnType: "Versioning" }],
+        propertyTypes: [{ name: "Bucket_Versioning", specType: "Versioning" }],
       },
     ];
     const naming = makeNaming(resources);

package/src/codegen/generate-registry.ts

@@ -15,11 +15,11 @@ export interface RegistryResource {
   typeName: string;
   attributes: { name: string }[];
   properties: { name: string; constraints: PropertyConstraints }[];
-  propertyTypes: { name: string; cfnType: string }[];
+  propertyTypes: { name: string; specType: string }[];
 }
 
 export interface RegistryConfig<E> {
-  /** Short name extractor (e.g. cfnShortName). */
+  /** Short name extractor (e.g. shortName from the spec type). */
   shortName: (typeName: string) => string;
   /** Build a resource entry from parsed data. */
   buildEntry: (
@@ -80,7 +80,7 @@ export function buildRegistry<E>(
     for (const pt of r.propertyTypes) {
       const defName = extractDefName(pt.name, shortName);
       const ptName = propertyTypeName(tsName, defName);
-      const ptEntry = config.buildPropertyEntry(typeName, pt.cfnType);
+      const ptEntry = config.buildPropertyEntry(typeName, pt.specType);
       entries[ptName] = ptEntry;
 
       if (ptAliases) {

package/src/codegen/package.ts

@@ -5,7 +5,7 @@
  * assemble BundleSpec → compute integrity → attach metadata.
  */
 
-import { readFileSync, readdirSync } from "fs";
+import { readFileSync, readdirSync, writeFileSync, mkdirSync } from "fs";
 import { join } from "path";
 import type { BundleSpec, LexiconManifest } from "../lexicon";
 import { computeIntegrity } from "../lexicon-integrity";
@@ -147,6 +147,33 @@ export function collectRules(
   return rules;
 }
 
+/**
+ * Write a BundleSpec to the given dist directory.
+ *
+ * Creates the directory structure and writes all artifacts:
+ * manifest.json, meta.json, types/index.d.ts, rules/*, skills/*, integrity.json.
+ */
+export function writeBundleSpec(spec: BundleSpec, distDir: string): void {
+  mkdirSync(join(distDir, "types"), { recursive: true });
+  mkdirSync(join(distDir, "rules"), { recursive: true });
+  mkdirSync(join(distDir, "skills"), { recursive: true });
+
+  writeFileSync(join(distDir, "manifest.json"), JSON.stringify(spec.manifest, null, 2));
+  writeFileSync(join(distDir, "meta.json"), spec.registry);
+  writeFileSync(join(distDir, "types", "index.d.ts"), spec.typesDTS);
+
+  for (const [name, content] of spec.rules) {
+    writeFileSync(join(distDir, "rules", name), content);
+  }
+  for (const [name, content] of spec.skills) {
+    writeFileSync(join(distDir, "skills", name), content);
+  }
+
+  if (spec.integrity) {
+    writeFileSync(join(distDir, "integrity.json"), JSON.stringify(spec.integrity, null, 2));
+  }
+}
+
 /**
  * Collect skills from a plugin's skill definitions.
  */

package/src/codegen/validate.ts

@@ -141,3 +141,19 @@ export async function validateLexiconArtifacts(config: LexiconValidationConfig):
     checks,
   };
 }
+
+/**
+ * Print validation results to stderr and throw on failure.
+ */
+export function printValidationResult(result: ValidateResult): void {
+  for (const check of result.checks) {
+    const status = check.ok ? "OK" : "FAIL";
+    const msg = check.error ? ` — ${check.error}` : "";
+    console.error(`  [${status}] ${check.name}${msg}`);
+  }
+
+  if (!result.success) {
+    throw new Error("Validation failed");
+  }
+  console.error("All validation checks passed.");
+}

package/src/discovery/files.ts

@@ -30,12 +30,12 @@ export async function findInfraFiles(path: string): Promise<string[]> {
       }
 
       if (entry.isDirectory()) {
-        // Child project boundary — a directory with its own barrel file is a
-        // separate scope, but only if we've already found the project's own
-        // source root (the first barrel directory). The project's own src/
-        // with _.ts is the source root, not a child project.
-        const barrelPath = join(fullPath, "_.ts");
-        if (existsSync(barrelPath)) {
+        // Child project boundary — a directory with its own chant.config.ts
+        // is a separate scope, but only if we've already found the project's
+        // own source root. The first config directory is the source root, not
+        // a child project.
+        const configPath = join(fullPath, "chant.config.ts");
+        if (existsSync(configPath)) {
           if (sourceRoot === null) {
             sourceRoot = fullPath;
           } else {

package/src/discovery/import.ts

@@ -11,7 +11,7 @@ export async function importModule(
   path: string
 ): Promise<Record<string, unknown>> {
   try {
-    return require(path);
+    return await import(path);
   } catch (error) {
     const message =
       error instanceof Error ? error.message : "Unknown import error";

package/src/index.ts

@@ -42,7 +42,6 @@ export * from "./lexicon-schema";
 export * from "./config";
 export * from "./validation";
 export * from "./project-validation";
-export { barrel } from "./barrel";
 export * from "./codegen/naming";
 export * from "./codegen/fetch";
 export * from "./codegen/generate";

package/src/lint/engine.ts

@@ -1,4 +1,4 @@
-import type { LintRule, LintDiagnostic, LintContext, LintRunOptions } from "./rule";
+import type { LintRule, LintDiagnostic, LintContext } from "./rule";
 import { parseFile } from "./parser";
 import { readFileSync } from "fs";
 
@@ -120,7 +120,6 @@ export async function runLint(
   files: string[],
   rules: LintRule[],
   ruleOptions?: Map<string, Record<string, unknown>>,
-  runOptions?: LintRunOptions,
 ): Promise<LintDiagnostic[]> {
   const allDiagnostics: LintDiagnostic[] = [];
   const allRuleIds = new Set(rules.map((r) => r.id));
@@ -140,9 +139,6 @@ export async function runLint(
         entities: [],
         filePath,
         lexicon: undefined,
-        barrelExports: runOptions?.barrelExports,
-        projectExports: runOptions?.projectExports,
-        projectScan: runOptions?.projectScan,
       };
 
       // Execute each rule

package/src/lint/rule.ts

@@ -56,24 +56,6 @@ export interface LintContext {
   filePath: string;
   /** Optional lexicon context (undefined for core rules) */
   lexicon?: string;
-  /** Export names from the barrel file (for EVL008) */
-  barrelExports?: Set<string>;
-  /** All project exports keyed by name (for EVL008) */
-  projectExports?: Map<string, { file: string; className: string }>;
-  /** Project scan result (for COR016) */
-  projectScan?: import("../project/scan").ProjectScan;
-}
-
-/**
- * Options for extending the lint context with project-level information
- */
-export interface LintRunOptions {
-  /** Export names from the barrel file */
-  barrelExports?: Set<string>;
-  /** All project exports keyed by name */
-  projectExports?: Map<string, { file: string; className: string }>;
-  /** Project scan result (for COR016) */
-  projectScan?: import("../project/scan").ProjectScan;
 }
 
 /**

package/src/lint/rules/evl009-composite-no-constant.test.ts

@@ -31,7 +31,7 @@ describe("EVL009: composite-no-constant", () => {
     expect(diags).toHaveLength(1);
     expect(diags[0].ruleId).toBe("EVL009");
     expect(diags[0].message).toContain("assumeRolePolicyDocument");
-    expect(diags[0].message).toContain("_.$.name");
+    expect(diags[0].message).toContain("import directly");
   });
 
   test("flags inline array with objects that doesn't reference props", () => {
@@ -61,11 +61,25 @@ describe("EVL009: composite-no-constant", () => {
     expect(diags[0].message).toContain("policies");
   });
 
-  test("allows barrel refs (_.$.name)", () => {
+  test("allows imported refs (direct import)", () => {
     const ctx = createContext(`
-      const MyComp = _.Composite((props) => {
+      import { lambdaTrustPolicy } from "./defaults";
+      const MyComp = Composite((props) => {
+        const role = new Role({
+          assumeRolePolicyDocument: lambdaTrustPolicy,
+        });
+        return { role };
+      }, "MyComp");
+    `);
+    expect(evl009CompositeNoConstantRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("allows namespace import refs", () => {
+    const ctx = createContext(`
+      import * as defaults from "./defaults";
+      const MyComp = Composite((props) => {
         const role = new Role({
-          assumeRolePolicyDocument: _.$.lambdaTrustPolicy,
+          assumeRolePolicyDocument: defaults.lambdaTrustPolicy,
         });
         return { role };
       }, "MyComp");
@@ -99,8 +113,9 @@ describe("EVL009: composite-no-constant", () => {
 
   test("allows sibling member reference", () => {
     const ctx = createContext(`
+      import { trustPolicy } from "./defaults";
       const MyComp = Composite((props) => {
-        const role = new Role({ assumeRolePolicyDocument: _.$.trustPolicy });
+        const role = new Role({ assumeRolePolicyDocument: trustPolicy });
         const func = new Function({
           config: { roleArn: role.arn },
         });
@@ -146,16 +161,17 @@ describe("EVL009: composite-no-constant", () => {
     expect(diags).toHaveLength(2);
   });
 
-  test("allows array wrapping barrel ref", () => {
+  test("allows array wrapping imported ref", () => {
     const ctx = createContext(`
+      import { lambdaBasicExecutionArn } from "./defaults";
       const MyComp = Composite((props) => {
         const role = new Role({
-          managedPolicyArns: [_.$.lambdaBasicExecutionArn],
+          managedPolicyArns: [lambdaBasicExecutionArn],
         });
         return { role };
       }, "MyComp");
     `);
-    // Array with barrel ref inside — not flagged (contains barrel ref)
+    // Array with imported ref inside — not flagged
     // Also it's an array of identifiers, no objects inside
     expect(evl009CompositeNoConstantRule.check(ctx)).toHaveLength(0);
   });