@intentius/chant 0.0.4 → 0.0.8

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

@@ -5,60 +5,78 @@ import { getCompositeFactory } from "./composite-scope";
 /**
  * EVL009: No extractable constants inside Composite factory
  *
- * Composite factories should only reference props, sibling members, and barrel refs.
- * Object literals and arrays-of-objects that don't reference any of these are
- * extractable constants that belong in a separate file (e.g. defaults.ts).
+ * Composite factories should only reference props, sibling members, and
+ * imported identifiers. Object literals and arrays-of-objects that don't
+ * reference any of these are extractable constants that belong in a
+ * separate file (e.g. defaults.ts).
  *
  * Triggers on: assumeRolePolicyDocument: { Version: "2012-10-17", Statement: [...] }
  * Triggers on: managedPolicyArns: ["arn:aws:iam::aws:policy/..."]
- * OK: assumeRolePolicyDocument: _.$.lambdaTrustPolicy
+ * OK: assumeRolePolicyDocument: lambdaTrustPolicy (imported)
  * OK: policies: props.policies
  * OK: role: role.arn
  * OK: action: "lambda:InvokeFunction" (simple string literal — not an object)
  */
 
+/**
+ * Collect all imported identifiers from import declarations in the file.
+ */
+function collectImportedNames(sourceFile: ts.SourceFile): Set<string> {
+  const names = new Set<string>();
+  for (const stmt of sourceFile.statements) {
+    if (!ts.isImportDeclaration(stmt) || !stmt.importClause) continue;
+
+    // import foo from "..."
+    if (stmt.importClause.name) {
+      names.add(stmt.importClause.name.text);
+    }
+
+    const bindings = stmt.importClause.namedBindings;
+    if (!bindings) continue;
+
+    if (ts.isNamespaceImport(bindings)) {
+      // import * as ns from "..."
+      names.add(bindings.name.text);
+    } else if (ts.isNamedImports(bindings)) {
+      // import { a, b } from "..."
+      for (const spec of bindings.elements) {
+        names.add(spec.name.text);
+      }
+    }
+  }
+  return names;
+}
+
 /**
  * Check whether any leaf node in the subtree references:
  * - The props parameter identifier
- * - A barrel ref (_.$ or $)
+ * - An imported identifier (direct import or namespace import)
  * - A local variable declared in the composite factory body
  */
 function referencesPropsOrMembers(
   node: ts.Node,
   propsName: string,
   localNames: Set<string>,
+  importedNames: Set<string>,
 ): boolean {
   if (ts.isIdentifier(node)) {
     // Direct props reference
     if (node.text === propsName) return true;
     // Local variable reference (sibling member)
     if (localNames.has(node.text)) return true;
-  }
-
-  // Barrel ref: _.$.something or $.something
-  if (ts.isPropertyAccessExpression(node)) {
-    if (isBarrelRef(node)) return true;
+    // Imported identifier (direct or namespace)
+    if (importedNames.has(node.text)) return true;
   }
 
   let found = false;
   ts.forEachChild(node, (child) => {
-    if (!found && referencesPropsOrMembers(child, propsName, localNames)) {
+    if (!found && referencesPropsOrMembers(child, propsName, localNames, importedNames)) {
       found = true;
     }
   });
   return found;
 }
 
-function isBarrelRef(node: ts.PropertyAccessExpression): boolean {
-  // _.$.x or $.x
-  const expr = node.expression;
-  if (ts.isIdentifier(expr) && expr.text === "$") return true;
-  if (ts.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.name) && expr.name.text === "$") {
-    return true;
-  }
-  return false;
-}
-
 /**
  * Check if a value is an extractable constant:
  * - Object literal (with any nesting)
@@ -79,6 +97,7 @@ function checkComposite(
   call: ts.CallExpression,
   context: LintContext,
   diagnostics: LintDiagnostic[],
+  importedNames: Set<string>,
 ): void {
   const factory = call.arguments[0];
   if (!factory || (!ts.isArrowFunction(factory) && !ts.isFunctionExpression(factory))) return;
@@ -103,7 +122,7 @@ function checkComposite(
   }
 
   // Walk all NewExpression nodes inside the factory body
-  checkForConstants(body, context, diagnostics, propsName, localNames);
+  checkForConstants(body, context, diagnostics, propsName, localNames, importedNames);
 }
 
 function checkForConstants(
@@ -112,6 +131,7 @@ function checkForConstants(
   diagnostics: LintDiagnostic[],
   propsName: string,
   localNames: Set<string>,
+  importedNames: Set<string>,
 ): void {
   if (ts.isNewExpression(node) && node.arguments && node.arguments.length > 0) {
     const firstArg = node.arguments[0];
@@ -120,7 +140,7 @@ function checkForConstants(
         if (!ts.isPropertyAssignment(prop)) continue;
         const value = prop.initializer;
 
-        if (isExtractableShape(value) && !referencesPropsOrMembers(value, propsName, localNames)) {
+        if (isExtractableShape(value) && !referencesPropsOrMembers(value, propsName, localNames, importedNames)) {
           const propName = ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)
             ? (ts.isIdentifier(prop.name) ? prop.name.text : prop.name.text)
             : "<computed>";
@@ -135,7 +155,7 @@ function checkForConstants(
             column: character + 1,
             ruleId: "EVL009",
             severity: "warning",
-            message: `Extractable constant in Composite factory property "${propName}" — move to a separate file and reference via _.$.name`,
+            message: `Extractable constant in Composite factory property "${propName}" — move to a separate file and import directly`,
           });
         }
       }
@@ -143,20 +163,20 @@ function checkForConstants(
   }
 
   ts.forEachChild(node, (child) =>
-    checkForConstants(child, context, diagnostics, propsName, localNames),
+    checkForConstants(child, context, diagnostics, propsName, localNames, importedNames),
   );
 }
 
-function checkNode(node: ts.Node, context: LintContext, diagnostics: LintDiagnostic[]): void {
+function checkNode(node: ts.Node, context: LintContext, diagnostics: LintDiagnostic[], importedNames: Set<string>): void {
   if (ts.isCallExpression(node)) {
     const factory = getCompositeFactory(node);
     if (factory) {
-      checkComposite(node, context, diagnostics);
+      checkComposite(node, context, diagnostics, importedNames);
       return; // Don't recurse further — checkComposite handles it
     }
   }
 
-  ts.forEachChild(node, (child) => checkNode(child, context, diagnostics));
+  ts.forEachChild(node, (child) => checkNode(child, context, diagnostics, importedNames));
 }
 
 export const evl009CompositeNoConstantRule: LintRule = {
@@ -165,7 +185,8 @@ export const evl009CompositeNoConstantRule: LintRule = {
   category: "style",
   check(context: LintContext): LintDiagnostic[] {
     const diagnostics: LintDiagnostic[] = [];
-    checkNode(context.sourceFile, context, diagnostics);
+    const importedNames = collectImportedNames(context.sourceFile);
+    checkNode(context.sourceFile, context, diagnostics, importedNames);
     return diagnostics;
   },
 };

package/src/lint/rules/index.ts

@@ -8,8 +8,6 @@ export { flatDeclarationsRule } from "./flat-declarations";
 export { exportRequiredRule } from "./export-required";
 export { fileDeclarableLimitRule } from "./file-declarable-limit";
 export { singleConcernFileRule } from "./single-concern-file";
-export { preferNamespaceImportRule } from "./prefer-namespace-import";
-export { barrelImportStyleRule } from "./barrel-import-style";
 export { declarableNamingConventionRule } from "./declarable-naming-convention";
 export { noUnusedDeclarableImportRule } from "./no-unused-declarable-import";
 export { noRedundantValueCastRule } from "./no-redundant-value-cast";
@@ -17,17 +15,12 @@ export { noUnusedDeclarableRule } from "./no-unused-declarable";
 export { noCyclicDeclarableRefRule } from "./no-cyclic-declarable-ref";
 export { noRedundantTypeImportRule } from "./no-redundant-type-import";
 export { noStringRefRule } from "./no-string-ref";
-export { enforceBarrelImportRule } from "./enforce-barrel-import";
-export { enforceBarrelRefRule } from "./enforce-barrel-ref";
 export { evl001NonLiteralExpressionRule } from "./evl001-non-literal-expression";
 export { evl002ControlFlowResourceRule } from "./evl002-control-flow-resource";
 export { evl003DynamicPropertyAccessRule } from "./evl003-dynamic-property-access";
 export { evl004SpreadNonConstRule } from "./evl004-spread-non-const";
 export { evl005ResourceBlockBodyRule } from "./evl005-resource-block-body";
-export { evl006BarrelUsageRule } from "./evl006-barrel-usage";
 export { evl007InvalidSiblingsRule } from "./evl007-invalid-siblings";
-export { evl008UnresolvableBarrelRefRule } from "./evl008-unresolvable-barrel-ref";
-export { staleBarrelTypesRule } from "./stale-barrel-types";
 export { evl009CompositeNoConstantRule } from "./evl009-composite-no-constant";
 export { evl010CompositeNoTransformRule } from "./evl010-composite-no-transform";
 export { cor017CompositeNameMatchRule } from "./cor017-composite-name-match";
@@ -37,8 +30,6 @@ import { flatDeclarationsRule } from "./flat-declarations";
 import { exportRequiredRule } from "./export-required";
 import { fileDeclarableLimitRule } from "./file-declarable-limit";
 import { singleConcernFileRule } from "./single-concern-file";
-import { preferNamespaceImportRule } from "./prefer-namespace-import";
-import { barrelImportStyleRule } from "./barrel-import-style";
 import { declarableNamingConventionRule } from "./declarable-naming-convention";
 import { noUnusedDeclarableImportRule } from "./no-unused-declarable-import";
 import { noRedundantValueCastRule } from "./no-redundant-value-cast";
@@ -46,24 +37,19 @@ import { noUnusedDeclarableRule } from "./no-unused-declarable";
 import { noCyclicDeclarableRefRule } from "./no-cyclic-declarable-ref";
 import { noRedundantTypeImportRule } from "./no-redundant-type-import";
 import { noStringRefRule } from "./no-string-ref";
-import { enforceBarrelImportRule } from "./enforce-barrel-import";
-import { enforceBarrelRefRule } from "./enforce-barrel-ref";
 import { evl001NonLiteralExpressionRule } from "./evl001-non-literal-expression";
 import { evl002ControlFlowResourceRule } from "./evl002-control-flow-resource";
 import { evl003DynamicPropertyAccessRule } from "./evl003-dynamic-property-access";
 import { evl004SpreadNonConstRule } from "./evl004-spread-non-const";
 import { evl005ResourceBlockBodyRule } from "./evl005-resource-block-body";
-import { evl006BarrelUsageRule } from "./evl006-barrel-usage";
 import { evl007InvalidSiblingsRule } from "./evl007-invalid-siblings";
-import { evl008UnresolvableBarrelRefRule } from "./evl008-unresolvable-barrel-ref";
-import { staleBarrelTypesRule } from "./stale-barrel-types";
 import { evl009CompositeNoConstantRule } from "./evl009-composite-no-constant";
 import { evl010CompositeNoTransformRule } from "./evl010-composite-no-transform";
 import { cor017CompositeNameMatchRule } from "./cor017-composite-name-match";
 import { cor018CompositePreferLexiconTypeRule } from "./cor018-composite-prefer-lexicon-type";
 
 /**
- * Load all 28 core lint rules (COR + EVL).
+ * Load all 21 core lint rules (COR + EVL).
  */
 export function loadCoreRules(): LintRule[] {
   return [
@@ -71,8 +57,6 @@ export function loadCoreRules(): LintRule[] {
     exportRequiredRule,
     fileDeclarableLimitRule,
     singleConcernFileRule,
-    preferNamespaceImportRule,
-    barrelImportStyleRule,
     declarableNamingConventionRule,
     noUnusedDeclarableImportRule,
     noRedundantValueCastRule,
@@ -80,17 +64,12 @@ export function loadCoreRules(): LintRule[] {
     noCyclicDeclarableRefRule,
     noRedundantTypeImportRule,
     noStringRefRule,
-    enforceBarrelImportRule,
-    enforceBarrelRefRule,
     evl001NonLiteralExpressionRule,
     evl002ControlFlowResourceRule,
     evl003DynamicPropertyAccessRule,
     evl004SpreadNonConstRule,
     evl005ResourceBlockBodyRule,
-    evl006BarrelUsageRule,
     evl007InvalidSiblingsRule,
-    evl008UnresolvableBarrelRefRule,
-    staleBarrelTypesRule,
     evl009CompositeNoConstantRule,
     evl010CompositeNoTransformRule,
     cor017CompositeNameMatchRule,

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/stack-output.ts

@@ -50,10 +50,10 @@ export function isStackOutput(value: unknown): value is StackOutput {
  * @example
  * ```ts
  * import { stackOutput } from "@intentius/chant";
- * import * as _ from "./_";
+ * import { vpc, subnet } from "./vpc";
  *
- * export const vpcId = stackOutput(_.$.vpc.vpcId);
- * export const subnetId = stackOutput(_.$.subnet.subnetId, {
+ * export const vpcId = stackOutput(vpc.vpcId);
+ * export const subnetId = stackOutput(subnet.subnetId, {
  *   description: "Primary subnet ID",
  * });
  * ```

package/src/barrel.test.ts

@@ -1,157 +0,0 @@
-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");
-  });
-});