@intentius/chant 0.0.1

package/src/lint/rules/index.ts

@@ -0,0 +1,99 @@
+/**
+ * Core lint rules for chant projects (COR + EVL).
+ */
+
+import type { LintRule } from "../rule";
+
+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";
+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";
+export { cor018CompositePreferLexiconTypeRule } from "./cor018-composite-prefer-lexicon-type";
+
+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";
+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).
+ */
+export function loadCoreRules(): LintRule[] {
+  return [
+    flatDeclarationsRule,
+    exportRequiredRule,
+    fileDeclarableLimitRule,
+    singleConcernFileRule,
+    preferNamespaceImportRule,
+    barrelImportStyleRule,
+    declarableNamingConventionRule,
+    noUnusedDeclarableImportRule,
+    noRedundantValueCastRule,
+    noUnusedDeclarableRule,
+    noCyclicDeclarableRefRule,
+    noRedundantTypeImportRule,
+    noStringRefRule,
+    enforceBarrelImportRule,
+    enforceBarrelRefRule,
+    evl001NonLiteralExpressionRule,
+    evl002ControlFlowResourceRule,
+    evl003DynamicPropertyAccessRule,
+    evl004SpreadNonConstRule,
+    evl005ResourceBlockBodyRule,
+    evl006BarrelUsageRule,
+    evl007InvalidSiblingsRule,
+    evl008UnresolvableBarrelRefRule,
+    staleBarrelTypesRule,
+    evl009CompositeNoConstantRule,
+    evl010CompositeNoTransformRule,
+    cor017CompositeNameMatchRule,
+    cor018CompositePreferLexiconTypeRule,
+  ];
+}

package/src/lint/rules/no-cyclic-declarable-ref.test.ts

@@ -0,0 +1,135 @@
+import { describe, test, expect } from "bun:test";
+import * as ts from "typescript";
+import { noCyclicDeclarableRefRule } from "./no-cyclic-declarable-ref";
+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("COR011: no-cyclic-declarable-ref", () => {
+  test("rule metadata", () => {
+    expect(noCyclicDeclarableRefRule.id).toBe("COR011");
+    expect(noCyclicDeclarableRefRule.severity).toBe("error");
+    expect(noCyclicDeclarableRefRule.category).toBe("correctness");
+  });
+
+  test("flags direct cycle: A references B, B references A", () => {
+    const ctx = createContext(
+      `export const bucket = new Bucket({ role: role.arn });\n` +
+        `export const role = new Role({ bucket: bucket.bucketName });`,
+    );
+    const diags = noCyclicDeclarableRefRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].ruleId).toBe("COR011");
+    expect(diags[0].severity).toBe("error");
+    expect(diags[0].message).toContain("bucket");
+    expect(diags[0].message).toContain("role");
+    expect(diags[0].message).toContain("Circular reference detected");
+  });
+
+  test("flags transitive cycle: A→B→C→A", () => {
+    const ctx = createContext(
+      `export const a = new ResourceA({ ref: b.id });\n` +
+        `export const b = new ResourceB({ ref: c.id });\n` +
+        `export const c = new ResourceC({ ref: a.id });`,
+    );
+    const diags = noCyclicDeclarableRefRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].message).toContain("a");
+    expect(diags[0].message).toContain("b");
+    expect(diags[0].message).toContain("c");
+  });
+
+  test("OK: linear chain A→B→C (no cycle)", () => {
+    const ctx = createContext(
+      `export const a = new ResourceA({});\n` +
+        `export const b = new ResourceB({ ref: a.id });\n` +
+        `export const c = new ResourceC({ ref: b.id });`,
+    );
+    const diags = noCyclicDeclarableRefRule.check(ctx);
+    expect(diags).toHaveLength(0);
+  });
+
+  test("OK: no cross-references between declarables", () => {
+    const ctx = createContext(
+      `export const bucket = new Bucket({ bucketName: "x" });\n` +
+        `export const role = new Role({ roleName: "y" });\n` +
+        `export const fn = new Function({ name: "z" });`,
+    );
+    const diags = noCyclicDeclarableRefRule.check(ctx);
+    expect(diags).toHaveLength(0);
+  });
+
+  test("OK: single declarable (cannot form a cycle)", () => {
+    const ctx = createContext(`export const bucket = new Bucket({ bucketName: "x" });`);
+    const diags = noCyclicDeclarableRefRule.check(ctx);
+    expect(diags).toHaveLength(0);
+  });
+
+  test("flags cycle with namespace import style", () => {
+    const ctx = createContext(
+      `import * as td from "@intentius/chant-lexicon-testdom";\n` +
+        `export const bucket = new td.Bucket({ role: role.arn });\n` +
+        `export const role = new td.Role({ bucket: bucket.bucketName });`,
+    );
+    const diags = noCyclicDeclarableRefRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].message).toContain("Circular reference detected");
+  });
+
+  test("reports correct file path", () => {
+    const ctx = createContext(
+      `export const bucket = new Bucket({ role: role.arn });\n` +
+        `export const role = new Role({ bucket: bucket.bucketName });`,
+      "infra/storage.ts",
+    );
+    const diags = noCyclicDeclarableRefRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].file).toBe("infra/storage.ts");
+  });
+
+  test("reports correct line and column", () => {
+    const ctx = createContext(
+      `import * as td from "@intentius/chant-lexicon-testdom";\n` +
+        `export const bucket = new td.Bucket({ role: role.arn });\n` +
+        `export const role = new td.Role({ bucket: bucket.bucketName });`,
+    );
+    const diags = noCyclicDeclarableRefRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].line).toBe(2);
+    expect(diags[0].column).toBe(1);
+  });
+
+  test("message includes arrow-separated cycle path", () => {
+    const ctx = createContext(
+      `export const bucket = new Bucket({ role: role.arn });\n` +
+        `export const role = new Role({ bucket: bucket.bucketName });`,
+    );
+    const diags = noCyclicDeclarableRefRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    // Should contain the cycle path with arrows
+    expect(diags[0].message).toMatch(/\u2192/);
+    expect(diags[0].message).toContain("Break the cycle by restructuring your declarations");
+  });
+
+  test("OK: non-exported declarables are ignored", () => {
+    const ctx = createContext(
+      `const bucket = new Bucket({ role: role.arn });\n` +
+        `const role = new Role({ bucket: bucket.bucketName });`,
+    );
+    const diags = noCyclicDeclarableRefRule.check(ctx);
+    expect(diags).toHaveLength(0);
+  });
+
+  test("detects cycle via direct identifier reference (not property access)", () => {
+    const ctx = createContext(
+      `export const bucket = new Bucket({ dep: role });\n` +
+        `export const role = new Role({ dep: bucket });`,
+    );
+    const diags = noCyclicDeclarableRefRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].message).toContain("Circular reference detected");
+  });
+});

package/src/lint/rules/no-cyclic-declarable-ref.ts

@@ -0,0 +1,178 @@
+import * as ts from "typescript";
+import type { LintRule, LintContext, LintDiagnostic } from "../rule";
+
+/**
+ * COR011: no-cyclic-declarable-ref
+ *
+ * Detects circular references between declarables in the same file.
+ * Builds a directed graph of declarable references and reports any cycles found.
+ *
+ * Triggers on: A references B, B references A (or longer transitive cycles)
+ * OK: A→B→C (linear chain, no cycle)
+ */
+
+interface DeclarableInfo {
+  name: string;
+  node: ts.VariableStatement;
+  initializer: ts.NewExpression;
+}
+
+function isCapitalized(name: string): boolean {
+  return name.length > 0 && name[0] === name[0].toUpperCase() && name[0] !== name[0].toLowerCase();
+}
+
+function getNewExpressionClassName(expr: ts.NewExpression): string | undefined {
+  if (ts.isIdentifier(expr.expression)) {
+    return expr.expression.text;
+  }
+  if (ts.isPropertyAccessExpression(expr.expression)) {
+    return expr.expression.name.text;
+  }
+  return undefined;
+}
+
+function collectExportedDeclarables(sourceFile: ts.SourceFile): DeclarableInfo[] {
+  const declarables: DeclarableInfo[] = [];
+
+  ts.forEachChild(sourceFile, (node) => {
+    if (!ts.isVariableStatement(node)) return;
+
+    const hasExport = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+    if (!hasExport) return;
+
+    for (const decl of node.declarationList.declarations) {
+      if (!ts.isIdentifier(decl.name)) continue;
+      if (!decl.initializer) continue;
+      if (!ts.isNewExpression(decl.initializer)) continue;
+
+      const className = getNewExpressionClassName(decl.initializer);
+      if (!className || !isCapitalized(className)) continue;
+
+      declarables.push({
+        name: decl.name.text,
+        node,
+        initializer: decl.initializer,
+      });
+    }
+  });
+
+  return declarables;
+}
+
+function collectReferencedDeclarables(
+  initializerNode: ts.Node,
+  declarableNames: Set<string>,
+): Set<string> {
+  const refs = new Set<string>();
+
+  function visit(node: ts.Node): void {
+    // Match property access like `role.arn` or plain identifier references
+    if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression)) {
+      if (declarableNames.has(node.expression.text)) {
+        refs.add(node.expression.text);
+      }
+    } else if (ts.isIdentifier(node)) {
+      // Direct identifier reference (e.g., passing `bucket` as an argument)
+      if (declarableNames.has(node.text)) {
+        // Make sure it's not part of a property access we already handled
+        const parent = node.parent;
+        if (!parent || !ts.isPropertyAccessExpression(parent) || parent.expression !== node) {
+          refs.add(node.text);
+        }
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  visit(initializerNode);
+  return refs;
+}
+
+function detectCycles(graph: Record<string, string[]>): string[][] {
+  const cycles: string[][] = [];
+  const visited = new Set<string>();
+  const recStack = new Set<string>();
+  const path: string[] = [];
+
+  function dfs(node: string): void {
+    visited.add(node);
+    recStack.add(node);
+    path.push(node);
+
+    const neighbors = graph[node] || [];
+    for (const neighbor of neighbors) {
+      if (!visited.has(neighbor)) {
+        dfs(neighbor);
+      } else if (recStack.has(neighbor)) {
+        const cycleStartIndex = path.indexOf(neighbor);
+        const cycle = path.slice(cycleStartIndex);
+        cycles.push(cycle);
+      }
+    }
+
+    recStack.delete(node);
+    path.pop();
+  }
+
+  for (const node of Object.keys(graph)) {
+    if (!visited.has(node)) {
+      dfs(node);
+    }
+  }
+
+  return cycles;
+}
+
+export const noCyclicDeclarableRefRule: LintRule = {
+  id: "COR011",
+  severity: "error",
+  category: "correctness",
+  check(context: LintContext): LintDiagnostic[] {
+    const diagnostics: LintDiagnostic[] = [];
+    const declarables = collectExportedDeclarables(context.sourceFile);
+
+    if (declarables.length < 2) return diagnostics;
+
+    const declarableNames = new Set(declarables.map((d) => d.name));
+    const declarableMap = new Map(declarables.map((d) => [d.name, d]));
+
+    // Build directed graph: A → B means A's constructor references B
+    const graph: Record<string, string[]> = {};
+    for (const decl of declarables) {
+      const refs = collectReferencedDeclarables(decl.initializer, declarableNames);
+      // Exclude self-references
+      refs.delete(decl.name);
+      graph[decl.name] = [...refs];
+    }
+
+    const cycles = detectCycles(graph);
+
+    // Track which nodes we've already reported to avoid duplicate diagnostics
+    const reported = new Set<string>();
+
+    for (const cycle of cycles) {
+      // Create a canonical key for the cycle to deduplicate
+      const cycleKey = [...cycle].sort().join(",");
+      if (reported.has(cycleKey)) continue;
+      reported.add(cycleKey);
+
+      const cyclePath = [...cycle, cycle[0]].join(" \u2192 ");
+      const firstDecl = declarableMap.get(cycle[0])!;
+      const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(
+        firstDecl.node.getStart(context.sourceFile),
+      );
+
+      diagnostics.push({
+        file: context.filePath,
+        line: line + 1,
+        column: character + 1,
+        ruleId: "COR011",
+        severity: "error",
+        message: `Circular reference detected: ${cyclePath}. Break the cycle by restructuring your declarations.`,
+      });
+    }
+
+    return diagnostics;
+  },
+};

package/src/lint/rules/no-redundant-type-import.test.ts

@@ -0,0 +1,129 @@
+import { describe, test, expect } from "bun:test";
+import * as ts from "typescript";
+import { noRedundantTypeImportRule } from "./no-redundant-type-import";
+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("COR012: no-redundant-type-import", () => {
+  test("rule metadata", () => {
+    expect(noRedundantTypeImportRule.id).toBe("COR012");
+    expect(noRedundantTypeImportRule.severity).toBe("warning");
+    expect(noRedundantTypeImportRule.category).toBe("style");
+  });
+
+  test("flags redundant type import alongside namespace import", () => {
+    const ctx = createContext(
+      `import * as td from "@intentius/chant-lexicon-testdom";\nimport type { PolicyDocument } from "@intentius/chant-lexicon-testdom";`
+    );
+    const diags = noRedundantTypeImportRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].ruleId).toBe("COR012");
+    expect(diags[0].message).toContain("td.PolicyDocument");
+    expect(diags[0].message).toContain("Redundant type import");
+  });
+
+  test("flags multiple type names in one import", () => {
+    const ctx = createContext(
+      `import * as td from "@intentius/chant-lexicon-testdom";\nimport type { PolicyDocument, Code, Environment } from "@intentius/chant-lexicon-testdom";`
+    );
+    const diags = noRedundantTypeImportRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].message).toContain("td.PolicyDocument");
+    expect(diags[0].message).toContain("td.Code");
+    expect(diags[0].message).toContain("td.Environment");
+  });
+
+  test("OK: type import alone without namespace import", () => {
+    const ctx = createContext(
+      `import type { PolicyDocument } from "@intentius/chant-lexicon-testdom";`
+    );
+    const diags = noRedundantTypeImportRule.check(ctx);
+    expect(diags).toHaveLength(0);
+  });
+
+  test("OK: namespace import alone without type import", () => {
+    const ctx = createContext(`import * as td from "@intentius/chant-lexicon-testdom";`);
+    const diags = noRedundantTypeImportRule.check(ctx);
+    expect(diags).toHaveLength(0);
+  });
+
+  test("OK: type import from non-@intentius/chant package", () => {
+    const ctx = createContext(
+      `import * as td from "@intentius/chant-lexicon-testdom";\nimport type { Foo } from "some-other-package";`
+    );
+    const diags = noRedundantTypeImportRule.check(ctx);
+    expect(diags).toHaveLength(0);
+  });
+
+  test("OK: type import from different @intentius/chant package than namespace", () => {
+    const ctx = createContext(
+      `import * as td from "@intentius/chant-lexicon-testdom";\nimport type { Foo } from "@intentius/chant";`
+    );
+    const diags = noRedundantTypeImportRule.check(ctx);
+    expect(diags).toHaveLength(0);
+  });
+
+  test("flags both when two packages each have namespace + type imports", () => {
+    const ctx = createContext(
+      [
+        `import * as td from "@intentius/chant-lexicon-testdom";`,
+        `import * as core from "@intentius/chant";`,
+        `import type { PolicyDocument } from "@intentius/chant-lexicon-testdom";`,
+        `import type { Entity } from "@intentius/chant";`,
+      ].join("\n")
+    );
+    const diags = noRedundantTypeImportRule.check(ctx);
+    expect(diags).toHaveLength(2);
+    expect(diags[0].message).toContain("td.PolicyDocument");
+    expect(diags[1].message).toContain("core.Entity");
+
+  });
+
+  test("message includes namespace alias and type names", () => {
+    const ctx = createContext(
+      `import * as myAlias from "@intentius/chant-lexicon-testdom";\nimport type { SomeType } from "@intentius/chant-lexicon-testdom";`
+    );
+    const diags = noRedundantTypeImportRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].message).toContain("myAlias.SomeType");
+  });
+
+  test("fix range covers the import line", () => {
+    const code = `import * as td from "@intentius/chant-lexicon-testdom";\nimport type { PolicyDocument } from "@intentius/chant-lexicon-testdom";\n`;
+    const ctx = createContext(code);
+    const diags = noRedundantTypeImportRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].fix).toBeDefined();
+    const fix = diags[0].fix!;
+    expect(fix.replacement).toBe("");
+    // Fix should cover the type import line
+    const removed = code.slice(fix.range[0], fix.range[1]);
+    expect(removed).toContain("import type");
+    expect(removed).toContain("PolicyDocument");
+    // Should not remove the namespace import
+    expect(removed).not.toContain("import * as aws");
+  });
+
+  test("does not flag non-type-only named imports", () => {
+    const ctx = createContext(
+      `import * as td from "@intentius/chant-lexicon-testdom";\nimport { PolicyDocument } from "@intentius/chant-lexicon-testdom";`
+    );
+    const diags = noRedundantTypeImportRule.check(ctx);
+    expect(diags).toHaveLength(0);
+  });
+
+  test("diagnostic has correct line and column", () => {
+    const ctx = createContext(
+      `import * as td from "@intentius/chant-lexicon-testdom";\nimport type { PolicyDocument } from "@intentius/chant-lexicon-testdom";`
+    );
+    const diags = noRedundantTypeImportRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].line).toBe(2);
+    expect(diags[0].column).toBeGreaterThan(0);
+    expect(diags[0].file).toBe("test.ts");
+  });
+});

package/src/lint/rules/no-redundant-type-import.ts

@@ -0,0 +1,85 @@
+import * as ts from "typescript";
+import type { LintRule, LintContext, LintDiagnostic } from "../rule";
+
+/**
+ * COR012: no-redundant-type-import
+ *
+ * Flag `import type { X } from "@intentius/chant-pkg"` when a namespace import
+ * `import * as pkg from "@intentius/chant-pkg"` already exists — the type is
+ * accessible as `pkg.X`.
+ */
+
+export const noRedundantTypeImportRule: LintRule = {
+  id: "COR012",
+  severity: "warning",
+  category: "style",
+  check(context: LintContext): LintDiagnostic[] {
+    const diagnostics: LintDiagnostic[] = [];
+    const sf = context.sourceFile;
+
+    // Pass 1: collect namespace imports from @intentius/chant* packages
+    // Map: module specifier → namespace alias
+    const namespaceImports = new Map<string, string>();
+
+    for (const stmt of sf.statements) {
+      if (
+        ts.isImportDeclaration(stmt) &&
+        ts.isStringLiteral(stmt.moduleSpecifier)
+      ) {
+        const modulePath = stmt.moduleSpecifier.text;
+        if (!modulePath.startsWith("@intentius/chant") && !modulePath.startsWith("@intentius/chant-lexicon-")) continue;
+        const clause = stmt.importClause;
+        if (clause && clause.namedBindings && ts.isNamespaceImport(clause.namedBindings)) {
+          namespaceImports.set(modulePath, clause.namedBindings.name.text);
+        }
+      }
+    }
+
+    if (namespaceImports.size === 0) return diagnostics;
+
+    // Pass 2: find type-only named imports from the same modules
+    for (const stmt of sf.statements) {
+      if (
+        ts.isImportDeclaration(stmt) &&
+        ts.isStringLiteral(stmt.moduleSpecifier)
+      ) {
+        const modulePath = stmt.moduleSpecifier.text;
+        const alias = namespaceImports.get(modulePath);
+        if (alias === undefined) continue;
+
+        const clause = stmt.importClause;
+        if (!clause || !clause.isTypeOnly) continue;
+        if (!clause.namedBindings || !ts.isNamedImports(clause.namedBindings)) continue;
+
+        const typeNames = clause.namedBindings.elements.map(e => e.name.text);
+        const qualifiedNames = typeNames.map(n => `${alias}.${n}`).join(", ");
+
+        const { line, character } = sf.getLineAndCharacterOfPosition(stmt.getStart(sf));
+
+        // Fix: remove the entire import line (including trailing newline)
+        const start = stmt.getFullStart();
+        const end = stmt.getEnd();
+        // Extend past trailing newline if present
+        const fullText = sf.getFullText();
+        let fixEnd = end;
+        if (fullText[fixEnd] === "\n") fixEnd++;
+        else if (fullText[fixEnd] === "\r" && fullText[fixEnd + 1] === "\n") fixEnd += 2;
+
+        diagnostics.push({
+          file: context.filePath,
+          line: line + 1,
+          column: character + 1,
+          ruleId: "COR012",
+          severity: "warning",
+          message: `Redundant type import — use ${qualifiedNames} instead. The namespace import already provides access to all exported types.`,
+          fix: {
+            range: [start, fixEnd],
+            replacement: "",
+          },
+        });
+      }
+    }
+
+    return diagnostics;
+  },
+};

package/src/lint/rules/no-redundant-value-cast.test.ts

@@ -0,0 +1,51 @@
+import { describe, test, expect } from "bun:test";
+import * as ts from "typescript";
+import { noRedundantValueCastRule } from "./no-redundant-value-cast";
+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("COR015: no-redundant-value-cast", () => {
+  test("rule metadata", () => {
+    expect(noRedundantValueCastRule.id).toBe("COR015");
+    expect(noRedundantValueCastRule.severity).toBe("warning");
+    expect(noRedundantValueCastRule.category).toBe("style");
+  });
+
+  test("flags as Value<string> cast", () => {
+    const ctx = createContext(`const x = role.arn as Value<string>;`);
+    const diags = noRedundantValueCastRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].ruleId).toBe("COR015");
+    expect(diags[0].message).toContain("Redundant");
+  });
+
+  test("flags as Value<number> cast", () => {
+    const ctx = createContext(`const x = something as Value<number>;`);
+    const diags = noRedundantValueCastRule.check(ctx);
+    expect(diags).toHaveLength(1);
+  });
+
+  test("does not flag other as casts", () => {
+    const ctx = createContext(`const x = something as string;`);
+    const diags = noRedundantValueCastRule.check(ctx);
+    expect(diags).toHaveLength(0);
+  });
+
+  test("does not flag when no cast is used", () => {
+    const ctx = createContext(`const x = role.arn;`);
+    const diags = noRedundantValueCastRule.check(ctx);
+    expect(diags).toHaveLength(0);
+  });
+
+  test("flags multiple casts in one file", () => {
+    const ctx = createContext(
+      `const a = x.arn as Value<string>;\nconst b = y.id as Value<string>;`
+    );
+    const diags = noRedundantValueCastRule.check(ctx);
+    expect(diags).toHaveLength(2);
+  });
+});