@intentius/chant 0.0.1

package/src/barrel.test.ts

@@ -0,0 +1,157 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { barrel } from "./barrel";
+
+let tempDir: string;
+
+beforeEach(() => {
+  tempDir = mkdtempSync(join(tmpdir(), "barrel-test-"));
+});
+
+afterEach(() => {
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+describe("barrel", () => {
+  test("returns exports from sibling .ts files", () => {
+    writeFileSync(
+      join(tempDir, "alpha.ts"),
+      "export const alphaValue = 42;",
+    );
+    writeFileSync(
+      join(tempDir, "beta.ts"),
+      "export const betaValue = 'hello';",
+    );
+
+    const $ = barrel(tempDir);
+
+    expect($.alphaValue).toBe(42);
+    expect($.betaValue).toBe("hello");
+  });
+
+  test("excludes files starting with underscore", () => {
+    writeFileSync(
+      join(tempDir, "_config.ts"),
+      "export const secret = 'hidden';",
+    );
+    writeFileSync(
+      join(tempDir, "visible.ts"),
+      "export const visible = true;",
+    );
+
+    const $ = barrel(tempDir);
+
+    expect($.secret).toBeUndefined();
+    expect($.visible).toBe(true);
+  });
+
+  test("excludes test files", () => {
+    writeFileSync(
+      join(tempDir, "foo.test.ts"),
+      "export const testVal = 1;",
+    );
+    writeFileSync(
+      join(tempDir, "bar.spec.ts"),
+      "export const specVal = 2;",
+    );
+    writeFileSync(
+      join(tempDir, "real.ts"),
+      "export const realVal = 3;",
+    );
+
+    const $ = barrel(tempDir);
+
+    expect($.testVal).toBeUndefined();
+    expect($.specVal).toBeUndefined();
+    expect($.realVal).toBe(3);
+  });
+
+  test("caches results after first access", () => {
+    writeFileSync(
+      join(tempDir, "mod.ts"),
+      "export const x = 1; export const y = 2;",
+    );
+
+    const $ = barrel(tempDir);
+
+    // First access triggers load
+    expect($.x).toBe(1);
+
+    // Write a new file after first load
+    writeFileSync(
+      join(tempDir, "late.ts"),
+      "export const lateVal = 99;",
+    );
+
+    // Should NOT pick up new file since cache is already populated
+    expect($.lateVal).toBeUndefined();
+    // Existing values still work
+    expect($.y).toBe(2);
+  });
+
+  test("returns undefined for missing keys", () => {
+    writeFileSync(
+      join(tempDir, "mod.ts"),
+      "export const exists = true;",
+    );
+
+    const $ = barrel(tempDir);
+
+    expect($.nonExistent).toBeUndefined();
+  });
+
+  test("has and ownKeys work correctly", () => {
+    writeFileSync(
+      join(tempDir, "mod.ts"),
+      "export const dataBucket = 's3://bucket';",
+    );
+
+    const $ = barrel(tempDir);
+
+    expect("dataBucket" in $).toBe(true);
+    expect("missing" in $).toBe(false);
+    expect(Object.keys($)).toEqual(["dataBucket"]);
+  });
+
+  test("handles empty directory", () => {
+    const $ = barrel(tempDir);
+
+    expect(Object.keys($)).toEqual([]);
+    expect($.anything).toBeUndefined();
+  });
+
+  test("handles load errors gracefully", () => {
+    writeFileSync(
+      join(tempDir, "broken.ts"),
+      "export const x = ;; SYNTAX ERROR @@#$",
+    );
+    writeFileSync(
+      join(tempDir, "good.ts"),
+      "export const goodVal = 'works';",
+    );
+
+    const $ = barrel(tempDir);
+
+    expect($.goodVal).toBe("works");
+  });
+
+  test("first export wins on name collision", () => {
+    // Files are sorted by readdirSync (OS-dependent), but we can verify
+    // that the proxy doesn't crash on collisions
+    writeFileSync(
+      join(tempDir, "aaa.ts"),
+      "export const shared = 'first';",
+    );
+    writeFileSync(
+      join(tempDir, "zzz.ts"),
+      "export const shared = 'second';",
+    );
+
+    const $ = barrel(tempDir);
+
+    // One of them wins (first by readdir order)
+    expect(typeof $.shared).toBe("string");
+  });
+});

package/src/barrel.ts

@@ -0,0 +1,101 @@
+import { readdirSync, readFileSync } from "fs";
+import { join } from "path";
+
+export function barrel(dir: string): Record<string, unknown> {
+  let allExports: Record<string, unknown> | null = null;
+
+  function load(): Record<string, unknown> {
+    if (allExports) return allExports;
+    allExports = {};
+
+    const files = readdirSync(dir)
+      .filter(
+        (f) =>
+          f.endsWith(".ts") &&
+          !f.startsWith("_") &&
+          !f.endsWith(".test.ts") &&
+          !f.endsWith(".spec.ts"),
+      )
+      .sort();
+
+    // Identify files that reference the barrel (.$. or .$[) — these
+    // may silently resolve cross-references to undefined if their
+    // dependency files haven't loaded yet
+    const barrelRefPattern = /\.\$[.\[]/;
+    const usesBarrel = new Set<string>();
+    for (const file of files) {
+      const src = readFileSync(join(dir, file), "utf-8");
+      if (barrelRefPattern.test(src)) {
+        usesBarrel.add(file);
+      }
+    }
+
+    function loadFile(file: string, overwrite = false): boolean {
+      const fullPath = join(dir, file);
+      try {
+        const mod = require(fullPath);
+        for (const [key, val] of Object.entries(mod)) {
+          if (val !== undefined && (overwrite || !(key in allExports!))) {
+            allExports![key] = val;
+          }
+        }
+        return true;
+      } catch {
+        // Clear require cache so retry re-executes the file
+        delete require.cache[require.resolve(fullPath)];
+        return false;
+      }
+    }
+
+    // First pass — load all files in alphabetical order
+    const failed: string[] = [];
+    for (const file of files) {
+      if (!loadFile(file)) {
+        failed.push(file);
+      }
+    }
+
+    // Retry files that threw — their dependencies are now available
+    for (const file of failed) {
+      loadFile(file);
+    }
+
+    // Second pass — reload files that reference the barrel so
+    // cross-references that silently resolved to undefined now
+    // pick up the correct values. Files without barrel references
+    // keep their original instances to preserve the reference graph.
+    for (const file of files) {
+      if (!usesBarrel.has(file)) continue;
+      const fullPath = join(dir, file);
+      try { delete require.cache[require.resolve(fullPath)]; } catch {}
+    }
+    for (const file of files) {
+      if (!usesBarrel.has(file)) continue;
+      loadFile(file, true);
+    }
+
+    return allExports;
+  }
+
+  return new Proxy<Record<string, unknown>>({}, {
+    get(_, prop: string | symbol) {
+      if (typeof prop === 'symbol') return undefined;
+      return load()[prop];
+    },
+    has(_, prop: string | symbol) {
+      if (typeof prop === 'symbol') return false;
+      return prop in load();
+    },
+    ownKeys(_) {
+      return Object.keys(load());
+    },
+    getOwnPropertyDescriptor(_, prop: string | symbol) {
+      if (typeof prop === 'symbol') return undefined;
+      const exports = load();
+      if (prop in exports) {
+        return { configurable: true, enumerable: true, value: exports[prop] };
+      }
+      return undefined;
+    },
+  });
+}

package/src/bench.test.ts

@@ -0,0 +1,227 @@
+import { describe, test, expect } from "bun:test";
+import { withTestDir } from "@intentius/chant-test-utils";
+import { writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { discover } from "./discovery/index";
+import { runLint } from "./lint/engine";
+import { build } from "./build";
+import type { Serializer } from "./serializer";
+import type { LintRule } from "./lint/rule";
+
+// Import all core lint rules
+import {
+  flatDeclarationsRule,
+  exportRequiredRule,
+  fileDeclarableLimitRule,
+  singleConcernFileRule,
+  preferNamespaceImportRule,
+  barrelImportStyleRule,
+  declarableNamingConventionRule,
+  noUnusedDeclarableImportRule,
+  noRedundantValueCastRule,
+  noUnusedDeclarableRule,
+  noCyclicDeclarableRefRule,
+  noRedundantTypeImportRule,
+  noStringRefRule,
+  enforceBarrelImportRule,
+  enforceBarrelRefRule,
+  evl001NonLiteralExpressionRule,
+  evl002ControlFlowResourceRule,
+  evl003DynamicPropertyAccessRule,
+  evl004SpreadNonConstRule,
+  evl005ResourceBlockBodyRule,
+  evl006BarrelUsageRule,
+  evl007InvalidSiblingsRule,
+  evl008UnresolvableBarrelRefRule,
+} from "./lint/rules/index";
+
+const coreRules: LintRule[] = [
+  flatDeclarationsRule,
+  exportRequiredRule,
+  fileDeclarableLimitRule,
+  singleConcernFileRule,
+  preferNamespaceImportRule,
+  barrelImportStyleRule,
+  declarableNamingConventionRule,
+  noUnusedDeclarableImportRule,
+  noRedundantValueCastRule,
+  noUnusedDeclarableRule,
+  noCyclicDeclarableRefRule,
+  noRedundantTypeImportRule,
+  noStringRefRule,
+  enforceBarrelImportRule,
+  enforceBarrelRefRule,
+  evl001NonLiteralExpressionRule,
+  evl002ControlFlowResourceRule,
+  evl003DynamicPropertyAccessRule,
+  evl004SpreadNonConstRule,
+  evl005ResourceBlockBodyRule,
+  evl006BarrelUsageRule,
+  evl007InvalidSiblingsRule,
+  evl008UnresolvableBarrelRefRule,
+];
+
+interface FixtureSize {
+  name: string;
+  files: number;
+  entitiesPerFile: number;
+}
+
+const sizes: FixtureSize[] = [
+  { name: "Small", files: 4, entitiesPerFile: 2 },
+  { name: "Medium", files: 20, entitiesPerFile: 2 },
+  { name: "Large", files: 100, entitiesPerFile: 2 },
+];
+
+function generateFixtureFile(index: number, entitiesPerFile: number): string {
+  const lines: string[] = [];
+  for (let i = 0; i < entitiesPerFile; i++) {
+    const n = index * entitiesPerFile + i;
+    lines.push(`export const config_${n} = {
+  lexicon: "bench",
+  entityType: "Config",
+  kind: "property",
+  [Symbol.for("chant.declarable")]: true,
+  algorithm: "AES256",
+};
+
+export const bucket_${n} = {
+  lexicon: "bench",
+  entityType: "Bucket",
+  [Symbol.for("chant.declarable")]: true,
+  bucketName: "bucket-${n}",
+  encryption: config_${n},
+};`);
+  }
+  return lines.join("\n\n");
+}
+
+async function generateFixture(dir: string, size: FixtureSize): Promise<string[]> {
+  const files: string[] = [];
+  for (let i = 0; i < size.files; i++) {
+    const filePath = join(dir, `infra-${String(i).padStart(3, "0")}.ts`);
+    await writeFile(filePath, generateFixtureFile(i, size.entitiesPerFile));
+    files.push(filePath);
+  }
+  return files;
+}
+
+async function timeMs<T>(fn: () => Promise<T>): Promise<{ result: T; ms: number }> {
+  const start = performance.now();
+  const result = await fn();
+  return { result, ms: performance.now() - start };
+}
+
+async function benchmark<T>(fn: () => Promise<T>, runs: number = 5): Promise<{ min: number; avg: number; max: number; result: T }> {
+  const times: number[] = [];
+  let lastResult!: T;
+  for (let i = 0; i < runs; i++) {
+    const { result, ms } = await timeMs(fn);
+    times.push(ms);
+    lastResult = result;
+  }
+  return {
+    min: Math.min(...times),
+    avg: times.reduce((a, b) => a + b, 0) / times.length,
+    max: Math.max(...times),
+    result: lastResult,
+  };
+}
+
+function fmt(ms: number): string {
+  return `${ms.toFixed(1)}ms`;
+}
+
+function pad(s: string, n: number): string {
+  return s.padEnd(n);
+}
+
+const benchSerializer: Serializer = {
+  name: "bench",
+  rulePrefix: "BENCH",
+  serialize: (entities) => JSON.stringify({ count: entities.size }),
+};
+
+describe("performance benchmarks", () => {
+  test("benchmark suite", async () => {
+    const output: string[] = [];
+    output.push("");
+    output.push("chant performance benchmarks");
+    output.push("============================");
+    output.push("");
+
+    // --- Fixture generation ---
+    output.push("Fixture generation:");
+
+    for (const size of sizes) {
+      await withTestDir(async (dir) => {
+        const totalEntities = size.files * size.entitiesPerFile;
+        const { ms } = await timeMs(() => generateFixture(dir, size));
+        output.push(`  ${pad(`${size.name} (${size.files} files, ~${totalEntities} entities)`, 42)} ${fmt(ms)}`);
+      });
+    }
+
+    output.push("");
+
+    // --- Discovery ---
+    output.push("Discovery:");
+
+    for (const size of sizes) {
+      await withTestDir(async (dir) => {
+        await generateFixture(dir, size);
+        const { avg } = await benchmark(() => discover(dir), 3);
+        output.push(`  ${pad(size.name, 10)} ${fmt(avg)} (avg of 3 runs)`);
+      });
+    }
+
+    output.push("");
+
+    // --- Lint ---
+    output.push(`Lint (${coreRules.length} core rules):`);
+
+    for (const size of sizes) {
+      await withTestDir(async (dir) => {
+        const files = await generateFixture(dir, size);
+        const { avg } = await benchmark(() => runLint(files, coreRules), 3);
+        output.push(`  ${pad(size.name, 10)} ${fmt(avg)} (avg of 3 runs)`);
+      });
+    }
+
+    output.push("");
+
+    // --- Build ---
+    output.push("Build (full pipeline):");
+
+    for (const size of sizes) {
+      await withTestDir(async (dir) => {
+        await generateFixture(dir, size);
+        const { avg } = await benchmark(() => build(dir, [benchSerializer]), 3);
+        output.push(`  ${pad(size.name, 10)} ${fmt(avg)} (avg of 3 runs)`);
+      });
+    }
+
+    output.push("");
+
+    // --- Startup ---
+    output.push("Startup:");
+
+    {
+      const { ms } = await timeMs(async () => {
+        await import("@intentius/chant");
+      });
+      output.push(`  import("@intentius/chant")  ${fmt(ms)}`);
+    }
+
+    output.push("");
+
+    // Print results
+    const report = output.join("\n");
+    console.log(report);
+
+    // Sanity assertions — just verify the benchmarks actually ran
+    expect(report).toContain("Discovery:");
+    expect(report).toContain("Lint");
+    expect(report).toContain("Build");
+    expect(report).toContain("Startup:");
+  }, 120_000);
+});