@intentius/chant 0.0.4 → 0.0.8

package/src/codegen/generate-registry.ts

@@ -8,18 +8,17 @@
 
 import type { NamingStrategy } from "./naming";
 import { propertyTypeName, extractDefName } from "./naming";
-import { toCamelCase } from "./case";
 import { constraintsIsEmpty, type PropertyConstraints } from "./json-schema";
 
 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: (
@@ -47,12 +46,12 @@ export function buildRegistry<E>(
     const tsName = naming.resolve(typeName);
     if (!tsName) continue;
 
-    // Build attrs map: camelCase → raw name
+    // Build attrs map: name → raw name (identity mapping)
     let attrs: Record<string, string> | undefined;
     if (r.attributes.length > 0) {
       attrs = {};
       for (const a of r.attributes) {
-        attrs[toCamelCase(a.name)] = a.name;
+        attrs[a.name] = a.name;
       }
     }
 
@@ -80,7 +79,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/generate-typescript.test.ts

@@ -18,8 +18,8 @@ describe("writeResourceClass", () => {
     );
     const output = lines.join("\n");
     expect(output).toContain("export declare class Bucket {");
-    expect(output).toContain("bucketName: string;");
-    expect(output).toContain("readonly arn: string;");
+    expect(output).toContain("BucketName: string;");
+    expect(output).toContain("readonly Arn: string;");
     expect(output).toContain("}");
   });
 
@@ -34,7 +34,7 @@ describe("writeResourceClass", () => {
       remap,
     );
     const output = lines.join("\n");
-    expect(output).toContain("readonly config: BucketConfig;");
+    expect(output).toContain("readonly Config: BucketConfig;");
   });
 });
 
@@ -48,7 +48,7 @@ describe("writePropertyClass", () => {
     );
     const output = lines.join("\n");
     expect(output).toContain("export declare class BucketConfig {");
-    expect(output).toContain("enabled?: boolean;");
+    expect(output).toContain("Enabled?: boolean;");
     expect(output).toContain("}");
   });
 });
@@ -71,8 +71,8 @@ describe("writeConstructor", () => {
       undefined,
     );
     const output = lines.join("\n");
-    const reqIdx = output.indexOf("required:");
-    const optIdx = output.indexOf("optional?:");
+    const reqIdx = output.indexOf("Required:");
+    const optIdx = output.indexOf("Optional?:");
     expect(reqIdx).toBeLessThan(optIdx);
   });
 

package/src/codegen/generate-typescript.ts

@@ -51,7 +51,7 @@ export function writeResourceClass(
   const attrs = [...attributes].sort((a, b) => a.name.localeCompare(b.name));
   for (const a of attrs) {
     const attrType = resolveConstructorType(a.type, remap);
-    lines.push(`  readonly ${toCamelCase(a.name)}: ${attrType};`);
+    lines.push(`  readonly ${a.name}: ${attrType};`);
   }
 
   lines.push("}");
@@ -98,7 +98,7 @@ export function writeConstructor(
     if (p.description) {
       lines.push(`    /** ${p.description} */`);
     }
-    lines.push(`    ${toCamelCase(p.name)}${optional}: ${tsType};`);
+    lines.push(`    ${p.name}${optional}: ${tsType};`);
   }
   lines.push("  });");
 }
@@ -155,7 +155,3 @@ export function resolveConstructorType(tsType: string, remap: Map<string, string
 
   return tsType;
 }
-
-function toCamelCase(name: string): string {
-  return name.charAt(0).toLowerCase() + name.slice(1);
-}

package/src/codegen/generate.ts

@@ -180,26 +180,15 @@ export interface WriteConfig {
   generatedSubdir?: string;
   /** Map of filename → content to write. */
   files: Record<string, string>;
-  /** Optional snapshot function called before overwriting. */
-  snapshot?: (generatedDir: string) => void;
 }
 
 /**
- * Write generated artifacts to disk with optional auto-snapshot.
+ * Write generated artifacts to disk.
  */
 export function writeGeneratedArtifacts(config: WriteConfig): void {
   const generatedDir = join(config.baseDir, config.generatedSubdir ?? "src/generated");
   mkdirSync(generatedDir, { recursive: true });
 
-  // Auto-snapshot before overwriting
-  if (config.snapshot) {
-    try {
-      config.snapshot(generatedDir);
-    } catch {
-      // Best effort — don't fail generation if snapshot fails
-    }
-  }
-
   for (const [filename, content] of Object.entries(config.files)) {
     writeFileSync(join(generatedDir, filename), content);
   }

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/typecheck.ts

@@ -4,6 +4,7 @@
 import { writeFileSync, mkdirSync, rmSync } from "fs";
 import { join } from "path";
 import { tmpdir } from "os";
+import { getRuntime } from "../runtime-adapter";
 
 export interface TypeCheckResult {
   ok: boolean;
@@ -39,17 +40,11 @@ export async function typecheckDTS(content: string): Promise<TypeCheckResult> {
     writeFileSync(join(dir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2));
 
     // Run tsc
-    const proc = Bun.spawn(["bunx", "tsc", "--noEmit", "--project", "tsconfig.json"], {
-      cwd: dir,
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-
-    const [stdout, stderr] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-    ]);
-    const exitCode = await proc.exited;
+    const rt = getRuntime();
+    const { stdout, stderr, exitCode } = await rt.spawn(
+      [rt.commands.exec, "tsc", "--noEmit", "--project", "tsconfig.json"],
+      { cwd: dir },
+    );
 
     // Parse diagnostics from stdout (tsc writes errors to stdout)
     const output = stdout + stderr;

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/config.ts

@@ -7,6 +7,7 @@ import type { LintConfig } from "./lint/config";
  * Zod schema for ChantConfig validation.
  */
 export const ChantConfigSchema = z.object({
+  runtime: z.enum(["bun", "node"]).optional(),
   lexicons: z.array(z.string().min(1)).optional(),
   lint: z.record(z.string(), z.unknown()).optional(),
 }).passthrough();
@@ -17,6 +18,9 @@ export const ChantConfigSchema = z.object({
  * Loaded from `chant.config.ts` (preferred) or `chant.config.json`.
  */
 export interface ChantConfig {
+  /** JS runtime to use for spawned commands: "bun" (default) or "node" */
+  runtime?: "bun" | "node";
+
   /** Lexicon package names to load (e.g. ["aws"]) */
   lexicons?: string[];
 

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,17 +42,16 @@ 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";
 export * from "./codegen/package";
 export * from "./codegen/typecheck";
-export * from "./codegen/rollback";
 export * from "./codegen/coverage";
 export * from "./codegen/validate";
 export * from "./codegen/docs";
 export * from "./runtime";
+export * from "./runtime-adapter";
 export * from "./stack-output";
 export * from "./child-project";
 export * from "./lsp/types";

package/src/lexicon-integrity.ts

@@ -2,18 +2,19 @@
  * Content hashing and integrity verification for lexicon artifacts.
  */
 import type { BundleSpec } from "./lexicon";
+import { getRuntime } from "./runtime-adapter";
 
 export interface ArtifactIntegrity {
-  algorithm: "xxhash64";
+  algorithm: string;
   artifacts: Record<string, string>;
   composite: string;
 }
 
 /**
- * Hash a single artifact's content using xxhash64.
+ * Hash a single artifact's content using the runtime's hash algorithm.
  */
 export function hashArtifact(content: string): string {
-  return Bun.hash(content).toString(16);
+  return getRuntime().hash(content);
 }
 
 /**
@@ -39,7 +40,7 @@ export function computeIntegrity(spec: BundleSpec): ArtifactIntegrity {
   const compositeInput = sorted.map(([k, v]) => `${k}:${v}`).join("\n");
   const composite = hashArtifact(compositeInput);
 
-  return { algorithm: "xxhash64", artifacts, composite };
+  return { algorithm: getRuntime().hashAlgorithm, artifacts, composite };
 }
 
 /**

package/src/lexicon.ts

@@ -101,7 +101,7 @@ export interface IntrinsicDef {
  * Plugin interface for lexicon packages.
  *
  * Required lifecycle methods enforce consistency: every lexicon must support
- * generate, validate, coverage, package, and rollback operations.
+ * generate, validate, coverage, and package operations.
  */
 export interface LexiconPlugin {
   // ── Required ──────────────────────────────────────────────
@@ -123,9 +123,6 @@ export interface LexiconPlugin {
   /** Package lexicon into distributable tarball */
   package(options?: { verbose?: boolean; force?: boolean }): Promise<void>;
 
-  /** List or restore generation snapshots */
-  rollback(options?: { restore?: string; verbose?: boolean }): Promise<void>;
-
   // ── Optional extensions ───────────────────────────────────
   /** Return lint rules provided by this lexicon */
   lintRules?(): LintRule[];
@@ -206,7 +203,6 @@ export function isLexiconPlugin(value: unknown): value is LexiconPlugin {
     typeof obj.generate === "function" &&
     typeof obj.validate === "function" &&
     typeof obj.coverage === "function" &&
-    typeof obj.package === "function" &&
-    typeof obj.rollback === "function"
+    typeof obj.package === "function"
   );
 }

package/src/lint/config.ts

@@ -1,13 +1,15 @@
 import { readFileSync, existsSync } from "fs";
 import { join, dirname, resolve } from "path";
+import { createRequire } from "module";
 import { z } from "zod";
 import type { Severity, RuleConfig } from "./rule";
+import { moduleDir, getRuntime } from "../runtime-adapter";
 import strictPreset from "./presets/strict.json";
 
 /** Mapping of built-in preset names to their file paths */
 const BUILTIN_PRESETS: Record<string, string> = {
-  "@intentius/chant/lint/presets/strict": resolve(import.meta.dir, "presets/strict.json"),
-  "@intentius/chant/lint/presets/relaxed": resolve(import.meta.dir, "presets/relaxed.json"),
+  "@intentius/chant/lint/presets/strict": resolve(moduleDir(import.meta.url), "presets/strict.json"),
+  "@intentius/chant/lint/presets/relaxed": resolve(moduleDir(import.meta.url), "presets/relaxed.json"),
 };
 
 // ── Zod schemas for lint config validation ─────────────────────────
@@ -307,11 +309,12 @@ function loadConfigFile(configPath: string, visited: Set<string> = new Set()): L
  * @returns Loaded and merged configuration, or default config if not found
  */
 export function loadConfig(dir: string): LintConfig {
-  // Try chant.config.ts first — Bun supports synchronous require() for .ts
+  // Try chant.config.ts first — Bun has native require() for .ts, Node uses tsx's loader
   const tsConfigPath = join(dir, "chant.config.ts");
   if (existsSync(tsConfigPath)) {
     try {
-      const mod = require(tsConfigPath);
+      const _require = createRequire(join(dir, "package.json"));
+      const mod = _require(tsConfigPath);
       const config = mod.default ?? mod.config ?? mod;
       if (typeof config === "object" && config !== null) {
         // ChantConfig format: extract lint property
@@ -362,8 +365,7 @@ export function resolveRulesForFile(config: LintConfig, filePath: string): Recor
 
   for (const override of config.overrides) {
     const matches = override.files.some((pattern) => {
-      const glob = new Bun.Glob(pattern);
-      return glob.match(filePath);
+      return getRuntime().globMatch(pattern, filePath);
     });
 
     if (matches) {

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);
   });