@intentius/chant 0.0.5 → 0.0.8

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

@@ -47,11 +47,11 @@ 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/runtime-adapter.ts

@@ -0,0 +1,158 @@
+/**
+ * Runtime adapter — abstracts Bun-specific APIs so chant can run on Bun or Node.js.
+ *
+ * Auto-detects the host runtime and delegates to the appropriate implementation.
+ * The `target` parameter (from config) controls what gets spawned (bun vs node/npx/npm),
+ * not which adapter class is used.
+ */
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { createHash } from "crypto";
+import { execFile } from "child_process";
+// @ts-ignore — picomatch has no types declaration
+import picomatch from "picomatch";
+
+export interface SpawnResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+export interface RuntimeCommands {
+  /** Runtime binary: "bun" | "node" */
+  runner: string;
+  /** Package executor: "bunx" | "npx" */
+  exec: string;
+  /** Pack command: ["bun", "pm", "pack"] | ["npm", "pack"] */
+  packCmd: string[];
+}
+
+export interface RuntimeAdapter {
+  readonly name: "bun" | "node";
+  /** Hash content and return hex string */
+  hash(content: string): string;
+  /** Algorithm name recorded in integrity.json */
+  readonly hashAlgorithm: string;
+  /** Test whether filePath matches a glob pattern */
+  globMatch(pattern: string, filePath: string): boolean;
+  /** Spawn a child process and collect output */
+  spawn(cmd: string[], opts?: { cwd?: string }): Promise<SpawnResult>;
+  /** Commands to use when spawning package manager / executor */
+  readonly commands: RuntimeCommands;
+}
+
+// ── Bun adapter ──────────────────────────────────────────────────
+
+class BunRuntimeAdapter implements RuntimeAdapter {
+  readonly name = "bun" as const;
+  readonly hashAlgorithm = "xxhash64";
+  readonly commands: RuntimeCommands;
+
+  constructor(target: "bun" | "node") {
+    this.commands =
+      target === "node"
+        ? { runner: "node", exec: "npx", packCmd: ["npm", "pack"] }
+        : { runner: "bun", exec: "bunx", packCmd: ["bun", "pm", "pack"] };
+  }
+
+  hash(content: string): string {
+    return Bun.hash(content).toString(16);
+  }
+
+  globMatch(pattern: string, filePath: string): boolean {
+    const glob = new Bun.Glob(pattern);
+    return glob.match(filePath);
+  }
+
+  async spawn(cmd: string[], opts?: { cwd?: string }): Promise<SpawnResult> {
+    const proc = Bun.spawn(cmd, {
+      cwd: opts?.cwd,
+      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;
+    return { stdout, stderr, exitCode };
+  }
+}
+
+// ── Node adapter ─────────────────────────────────────────────────
+
+class NodeRuntimeAdapter implements RuntimeAdapter {
+  readonly name = "node" as const;
+  readonly hashAlgorithm = "sha256";
+  readonly commands: RuntimeCommands;
+
+  constructor(target: "bun" | "node") {
+    this.commands =
+      target === "bun"
+        ? { runner: "bun", exec: "bunx", packCmd: ["bun", "pm", "pack"] }
+        : { runner: "node", exec: "npx", packCmd: ["npm", "pack"] };
+  }
+
+  hash(content: string): string {
+    return createHash("sha256").update(content).digest("hex");
+  }
+
+  globMatch(pattern: string, filePath: string): boolean {
+    return picomatch(pattern)(filePath);
+  }
+
+  async spawn(cmd: string[], opts?: { cwd?: string }): Promise<SpawnResult> {
+    return new Promise((resolve) => {
+      execFile(cmd[0], cmd.slice(1), { cwd: opts?.cwd, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+        resolve({
+          stdout: stdout ?? "",
+          stderr: stderr ?? "",
+          exitCode: err ? (err as any).code ?? 1 : 0,
+        });
+      });
+    });
+  }
+}
+
+// ── Singleton ────────────────────────────────────────────────────
+
+let _runtime: RuntimeAdapter | undefined;
+
+/**
+ * Detect whether we're running under Bun.
+ */
+function isBun(): boolean {
+  return typeof globalThis.Bun !== "undefined";
+}
+
+/**
+ * Initialize the runtime adapter singleton.
+ *
+ * @param target - Which commands to spawn ("bun" or "node"). Defaults to auto-detect.
+ *   Controls the `commands` property, not which adapter class is used.
+ */
+export function initRuntime(target?: "bun" | "node"): RuntimeAdapter {
+  const resolvedTarget = target ?? (isBun() ? "bun" : "node");
+  _runtime = isBun()
+    ? new BunRuntimeAdapter(resolvedTarget)
+    : new NodeRuntimeAdapter(resolvedTarget);
+  return _runtime;
+}
+
+/**
+ * Get the runtime adapter. Lazily initializes with auto-detection if not yet set.
+ */
+export function getRuntime(): RuntimeAdapter {
+  if (!_runtime) {
+    return initRuntime();
+  }
+  return _runtime;
+}
+
+/**
+ * Convert `import.meta.url` to a directory path.
+ * Works on both Bun and Node (replaces Bun-only `import.meta.dir`).
+ */
+export function moduleDir(importMetaUrl: string): string {
+  return dirname(fileURLToPath(importMetaUrl));
+}

package/src/serializer-walker.test.ts

@@ -93,15 +93,6 @@ describe("walkValue", () => {
     expect(walkValue({ a: 1, b: { c: 2 } }, names, mockVisitor)).toEqual({ a: 1, b: { c: 2 } });
   });
 
-  test("applies transformKey when provided", () => {
-    const visitor: SerializerVisitor = {
-      ...mockVisitor,
-      transformKey: (k) => k.toUpperCase(),
-    };
-    const names = new Map<Declarable, string>();
-    expect(walkValue({ foo: 1, bar: 2 }, names, visitor)).toEqual({ FOO: 1, BAR: 2 });
-  });
-
   test("complex nested structure", () => {
     const resource = makeDeclarable("Test::Role");
     const ref = new AttrRef(resource, "arn");

package/src/serializer-walker.ts

@@ -17,8 +17,6 @@ export interface SerializerVisitor {
   resourceRef(logicalName: string): unknown;
   /** Format a property-level Declarable by walking its props. */
   propertyDeclarable(entity: Declarable, walk: (v: unknown) => unknown): unknown;
-  /** Optional key transformation (e.g. camelCase → PascalCase). */
-  transformKey?(key: string): string;
 }
 
 /**
@@ -73,7 +71,7 @@ export function walkValue(
   if (typeof value === "object") {
     const result: Record<string, unknown> = {};
     for (const [key, val] of Object.entries(value)) {
-      const outKey = visitor.transformKey ? visitor.transformKey(key) : key;
+      const outKey = key;
       result[outKey] = walkValue(val, entityNames, visitor);
     }
     return result;

package/src/cli/commands/__fixtures__/init-lexicon-output/src/codegen/rollback.ts

@@ -1,45 +0,0 @@
-import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, cpSync } from "fs";
-import { join, basename } from "path";
-
-export interface Snapshot {
-  timestamp: string;
-  resources: number;
-  path: string;
-}
-
-/**
- * List available generation snapshots.
- */
-export function listSnapshots(snapshotsDir: string): Snapshot[] {
-  if (!existsSync(snapshotsDir)) return [];
-
-  return readdirSync(snapshotsDir)
-    .filter((d) => !d.startsWith("."))
-    .sort()
-    .reverse()
-    .map((dir) => {
-      const fullPath = join(snapshotsDir, dir);
-      const metaPath = join(fullPath, "meta.json");
-      let resources = 0;
-      if (existsSync(metaPath)) {
-        try {
-          const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
-          resources = meta.resources ?? 0;
-        } catch {}
-      }
-      return { timestamp: dir, resources, path: fullPath };
-    });
-}
-
-/**
- * Restore a snapshot to the generated directory.
- */
-export function restoreSnapshot(timestamp: string, generatedDir: string): void {
-  const snapshotsDir = join(generatedDir, "..", "..", ".snapshots");
-  const snapshotDir = join(snapshotsDir, timestamp);
-  if (!existsSync(snapshotDir)) {
-    throw new Error(`Snapshot not found: ${timestamp}`);
-  }
-  mkdirSync(generatedDir, { recursive: true });
-  cpSync(snapshotDir, generatedDir, { recursive: true });
-}

package/src/codegen/case.test.ts

@@ -1,30 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { toCamelCase, toPascalCase } from "./case";
-
-describe("toCamelCase", () => {
-  test("lowercases first character", () => {
-    expect(toCamelCase("BucketName")).toBe("bucketName");
-  });
-
-  test("preserves already-camelCase", () => {
-    expect(toCamelCase("already")).toBe("already");
-  });
-
-  test("handles single character", () => {
-    expect(toCamelCase("A")).toBe("a");
-  });
-});
-
-describe("toPascalCase", () => {
-  test("uppercases first character", () => {
-    expect(toPascalCase("bucketName")).toBe("BucketName");
-  });
-
-  test("preserves already-PascalCase", () => {
-    expect(toPascalCase("Already")).toBe("Already");
-  });
-
-  test("handles single character", () => {
-    expect(toPascalCase("a")).toBe("A");
-  });
-});

package/src/codegen/case.ts

@@ -1,11 +0,0 @@
-/**
- * Case conversion utilities for codegen.
- */
-
-export function toCamelCase(name: string): string {
-  return name.charAt(0).toLowerCase() + name.slice(1);
-}
-
-export function toPascalCase(name: string): string {
-  return name.charAt(0).toUpperCase() + name.slice(1);
-}

package/src/codegen/rollback.test.ts

@@ -1,92 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { mkdirSync, writeFileSync, rmSync, readFileSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-import { snapshotArtifacts, saveSnapshot, restoreSnapshot, listSnapshots } from "./rollback";
-
-function makeTempDir(): string {
-  const dir = join(tmpdir(), `chant-rollback-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-  mkdirSync(dir, { recursive: true });
-  return dir;
-}
-
-describe("rollback", () => {
-  test("snapshot captures generated files with default artifact names", () => {
-    const dir = makeTempDir();
-    const genDir = join(dir, "generated");
-    mkdirSync(genDir, { recursive: true });
-
-    writeFileSync(join(genDir, "lexicon.json"), '{"Bucket":{"kind":"resource"}}');
-    writeFileSync(join(genDir, "index.d.ts"), "declare class Bucket {}");
-    writeFileSync(join(genDir, "index.ts"), "export const Bucket = {};");
-
-    const snapshot = snapshotArtifacts(genDir);
-    expect(snapshot.files["lexicon.json"]).toBeDefined();
-    expect(snapshot.files["index.d.ts"]).toBeDefined();
-    expect(snapshot.files["index.ts"]).toBeDefined();
-    expect(snapshot.hashes["lexicon.json"]).toBeDefined();
-    expect(snapshot.resourceCount).toBe(1);
-
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  test("snapshot uses custom artifact names", () => {
-    const dir = makeTempDir();
-    const genDir = join(dir, "generated");
-    mkdirSync(genDir, { recursive: true });
-
-    writeFileSync(join(genDir, "my-lexicon.json"), '{"Resource":{"kind":"resource"}}');
-    writeFileSync(join(genDir, "types.d.ts"), "declare class Resource {}");
-
-    const snapshot = snapshotArtifacts(genDir, ["my-lexicon.json", "types.d.ts"]);
-    expect(snapshot.files["my-lexicon.json"]).toBeDefined();
-    expect(snapshot.files["types.d.ts"]).toBeDefined();
-    expect(snapshot.resourceCount).toBe(1);
-
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  test("save and list snapshots", () => {
-    const dir = makeTempDir();
-    const snapshotsDir = join(dir, ".snapshots");
-
-    const snapshot = {
-      timestamp: "2025-01-01T00:00:00.000Z",
-      files: { "test.json": "{}" },
-      hashes: { "test.json": "abc123" },
-      resourceCount: 0,
-    };
-
-    saveSnapshot(snapshot, snapshotsDir);
-    const list = listSnapshots(snapshotsDir);
-    expect(list.length).toBe(1);
-    expect(list[0].timestamp).toBe("2025-01-01T00:00:00.000Z");
-
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  test("restore snapshot overwrites generated files", () => {
-    const dir = makeTempDir();
-    const genDir = join(dir, "generated");
-    const snapshotsDir = join(dir, ".snapshots");
-    mkdirSync(genDir, { recursive: true });
-
-    writeFileSync(join(genDir, "lexicon.json"), '{"original":true}');
-
-    const snapshot = snapshotArtifacts(genDir);
-    const snapshotPath = saveSnapshot(snapshot, snapshotsDir);
-
-    writeFileSync(join(genDir, "lexicon.json"), '{"modified":true}');
-    expect(readFileSync(join(genDir, "lexicon.json"), "utf-8")).toBe('{"modified":true}');
-
-    restoreSnapshot(snapshotPath, genDir);
-    expect(readFileSync(join(genDir, "lexicon.json"), "utf-8")).toBe('{"original":true}');
-
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  test("listSnapshots returns empty for nonexistent dir", () => {
-    const list = listSnapshots("/nonexistent/path");
-    expect(list).toHaveLength(0);
-  });
-});