@intentius/chant 0.0.3 → 0.0.5

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

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

package/src/barrel.ts

@@ -1,101 +0,0 @@
-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/lint/rules/barrel-import-style.test.ts

@@ -1,80 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import * as ts from "typescript";
-import { barrelImportStyleRule } from "./barrel-import-style";
-import type { LintContext } from "../rule";
-
-function createContext(code: string, filePath = "test.ts"): LintContext {
-  const sourceFile = ts.createSourceFile(
-    filePath,
-    code,
-    ts.ScriptTarget.Latest,
-    true
-  );
-
-  return {
-    sourceFile,
-    entities: [],
-    filePath,
-    lexicon: undefined,
-  };
-}
-
-describe("COR002: barrel-import-style", () => {
-  test("rule metadata", () => {
-    expect(barrelImportStyleRule.id).toBe("COR002");
-    expect(barrelImportStyleRule.severity).toBe("error");
-    expect(barrelImportStyleRule.category).toBe("style");
-  });
-
-  test("flags named import from ./_", () => {
-    const code = `import { bucketEncryption } from "./_";`;
-    const context = createContext(code);
-    const diagnostics = barrelImportStyleRule.check(context);
-
-    expect(diagnostics).toHaveLength(1);
-    expect(diagnostics[0].ruleId).toBe("COR002");
-    expect(diagnostics[0].severity).toBe("error");
-    expect(diagnostics[0].message).toBe(
-      `Use namespace import for local barrel — replace with: import * as _ from "./_"`
-    );
-  });
-
-  test("allows namespace import from ./_", () => {
-    const code = `import * as _ from "./_";`;
-    const context = createContext(code);
-    const diagnostics = barrelImportStyleRule.check(context);
-    expect(diagnostics).toHaveLength(0);
-  });
-
-  test("allows type-only import from ./_", () => {
-    const code = `import type { Config } from "./_";`;
-    const context = createContext(code);
-    const diagnostics = barrelImportStyleRule.check(context);
-    expect(diagnostics).toHaveLength(0);
-  });
-
-  test("does not flag imports from other relative paths", () => {
-    const code = `import { helper } from "./utils";`;
-    const context = createContext(code);
-    const diagnostics = barrelImportStyleRule.check(context);
-    expect(diagnostics).toHaveLength(0);
-  });
-
-  test("does not flag imports from packages", () => {
-    const code = `import { useState } from "react";`;
-    const context = createContext(code);
-    const diagnostics = barrelImportStyleRule.check(context);
-    expect(diagnostics).toHaveLength(0);
-  });
-
-  test("reports correct line and column numbers", () => {
-    const code = `import { foo } from "./_";`;
-    const context = createContext(code);
-    const diagnostics = barrelImportStyleRule.check(context);
-
-    expect(diagnostics).toHaveLength(1);
-    expect(diagnostics[0].line).toBe(1);
-    expect(diagnostics[0].column).toBe(1);
-    expect(diagnostics[0].file).toBe("test.ts");
-  });
-});