@intentius/chant 0.0.1

package/src/lint/rules/evl004-spread-non-const.test.ts

@@ -0,0 +1,130 @@
+import { describe, test, expect } from "bun:test";
+import * as ts from "typescript";
+import { evl004SpreadNonConstRule } from "./evl004-spread-non-const";
+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("EVL004: spread-non-const", () => {
+  test("rule metadata", () => {
+    expect(evl004SpreadNonConstRule.id).toBe("EVL004");
+    expect(evl004SpreadNonConstRule.severity).toBe("error");
+    expect(evl004SpreadNonConstRule.category).toBe("correctness");
+  });
+
+  test("allows spread from const variable", () => {
+    const ctx = createContext(`
+      const base = { a: 1, b: 2 };
+      const merged = { ...base, c: 3 };
+    `);
+    expect(evl004SpreadNonConstRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("allows spread from object literal", () => {
+    const ctx = createContext(`const x = { ...{ a: 1 }, b: 2 };`);
+    expect(evl004SpreadNonConstRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("allows spread from const property access", () => {
+    const ctx = createContext(`
+      const config = { base: { a: 1 } };
+      const x = { ...config.base };
+    `);
+    expect(evl004SpreadNonConstRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("flags spread from let variable", () => {
+    const ctx = createContext(`
+      let base = { a: 1 };
+      const x = { ...base };
+    `);
+    const diags = evl004SpreadNonConstRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].ruleId).toBe("EVL004");
+    expect(diags[0].message).toContain("non-const");
+  });
+
+  test("flags spread from function call", () => {
+    const ctx = createContext(`const x = { ...getDefaults() };`);
+    expect(evl004SpreadNonConstRule.check(ctx)).toHaveLength(1);
+  });
+
+  test("flags spread from method call", () => {
+    const ctx = createContext(`const x = { ...config.getDefaults() };`);
+    expect(evl004SpreadNonConstRule.check(ctx)).toHaveLength(1);
+  });
+
+  test("flags array spread from non-const", () => {
+    const ctx = createContext(`
+      let items = [1, 2];
+      const x = [...items, 3];
+    `);
+    expect(evl004SpreadNonConstRule.check(ctx)).toHaveLength(1);
+  });
+
+  test("allows array spread from const", () => {
+    const ctx = createContext(`
+      const items = [1, 2];
+      const x = [...items, 3];
+    `);
+    expect(evl004SpreadNonConstRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("flags multiple violations", () => {
+    const ctx = createContext(`
+      let a = {};
+      let b = [];
+      const x = { ...a };
+      const y = [...b];
+    `);
+    expect(evl004SpreadNonConstRule.check(ctx)).toHaveLength(2);
+  });
+
+  test("allows spread inside Composite() factory callback", () => {
+    const ctx = createContext(`
+      function SecureApi(props) {
+        return LambdaApi({
+          timeout: 10,
+          ...props,
+        });
+      }
+    `);
+    // This is a regular function, NOT inside Composite — should still flag
+    expect(evl004SpreadNonConstRule.check(ctx)).toHaveLength(1);
+  });
+
+  test("allows spread inside Composite() definition", () => {
+    const ctx = createContext(`
+      const MyComp = Composite((props) => {
+        const role = new Role({ ...props.roleConfig });
+        return { role };
+      });
+    `);
+    expect(evl004SpreadNonConstRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("allows spread inside _.Composite() definition", () => {
+    const ctx = createContext(`
+      const MyComp = _.Composite((props) => {
+        const role = new _.Role({ ...props.defaults, name: props.name });
+        return { role };
+      });
+    `);
+    expect(evl004SpreadNonConstRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("still flags outside Composite() in same file", () => {
+    const ctx = createContext(`
+      const MyComp = Composite((props) => {
+        const role = new Role({ ...props.config });
+        return { role };
+      });
+      let defaults = {};
+      const x = { ...defaults };
+    `);
+    expect(evl004SpreadNonConstRule.check(ctx)).toHaveLength(1);
+  });
+});

package/src/lint/rules/evl004-spread-non-const.ts

@@ -0,0 +1,111 @@
+import * as ts from "typescript";
+import type { LintRule, LintContext, LintDiagnostic } from "../rule";
+import { isInsideCompositeFactory } from "./composite-scope";
+
+/**
+ * EVL004: Spread From Non-Const Source
+ *
+ * Spread expressions ({...x} or [...x]) must reference a const-declared
+ * variable, object literal, or property access chain from a const.
+ * Spreading from function calls or non-traceable sources is blocked.
+ */
+
+function isTraceableToConst(node: ts.Node, sourceFile: ts.SourceFile): boolean {
+  // Object or array literals are fine
+  if (ts.isObjectLiteralExpression(node) || ts.isArrayLiteralExpression(node)) {
+    return true;
+  }
+
+  // Property access: follow the chain to the root
+  if (ts.isPropertyAccessExpression(node)) {
+    return isTraceableToConst(node.expression, sourceFile);
+  }
+
+  // Identifier — check if it's a const declaration
+  if (ts.isIdentifier(node)) {
+    return isConstIdentifier(node, sourceFile);
+  }
+
+  // Parenthesized
+  if (ts.isParenthesizedExpression(node)) {
+    return isTraceableToConst(node.expression, sourceFile);
+  }
+
+  // As/satisfies cast
+  if (ts.isAsExpression(node) || ts.isSatisfiesExpression(node)) {
+    return isTraceableToConst(node.expression, sourceFile);
+  }
+
+  return false;
+}
+
+function isConstIdentifier(id: ts.Identifier, sourceFile: ts.SourceFile): boolean {
+  // Walk all statements looking for a const declaration of this identifier
+  for (const stmt of sourceFile.statements) {
+    if (ts.isVariableStatement(stmt)) {
+      if (stmt.declarationList.flags & ts.NodeFlags.Const) {
+        for (const decl of stmt.declarationList.declarations) {
+          if (ts.isIdentifier(decl.name) && decl.name.text === id.text) {
+            return true;
+          }
+        }
+      }
+    }
+  }
+  return false;
+}
+
+function checkNode(node: ts.Node, context: LintContext, diagnostics: LintDiagnostic[]): void {
+  // Skip spreads inside Composite() factory callbacks
+  if (isInsideCompositeFactory(node)) {
+    ts.forEachChild(node, (child) => checkNode(child, context, diagnostics));
+    return;
+  }
+
+  // Spread in object literal: { ...expr }
+  if (ts.isSpreadAssignment(node)) {
+    if (!isTraceableToConst(node.expression, context.sourceFile)) {
+      const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(
+        node.getStart(context.sourceFile),
+      );
+      diagnostics.push({
+        file: context.filePath,
+        line: line + 1,
+        column: character + 1,
+        ruleId: "EVL004",
+        severity: "error",
+        message: "Spread from non-const source — spread expression must reference a const variable or literal",
+      });
+    }
+  }
+
+  // Spread in array literal: [...expr]
+  if (ts.isSpreadElement(node)) {
+    if (!isTraceableToConst(node.expression, context.sourceFile)) {
+      const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(
+        node.getStart(context.sourceFile),
+      );
+      diagnostics.push({
+        file: context.filePath,
+        line: line + 1,
+        column: character + 1,
+        ruleId: "EVL004",
+        severity: "error",
+        message: "Spread from non-const source — spread expression must reference a const variable or literal",
+      });
+    }
+  }
+
+  ts.forEachChild(node, (child) => checkNode(child, context, diagnostics));
+}
+
+export const evl004SpreadNonConstRule: LintRule = {
+  id: "EVL004",
+  severity: "error",
+  category: "correctness",
+  check(context: LintContext): LintDiagnostic[] {
+    const diagnostics: LintDiagnostic[] = [];
+    checkNode(context.sourceFile, context, diagnostics);
+    return diagnostics;
+  },
+};

package/src/lint/rules/evl005-resource-block-body.test.ts

@@ -0,0 +1,59 @@
+import { describe, test, expect } from "bun:test";
+import * as ts from "typescript";
+import { evl005ResourceBlockBodyRule } from "./evl005-resource-block-body";
+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("EVL005: resource-block-body", () => {
+  test("rule metadata", () => {
+    expect(evl005ResourceBlockBodyRule.id).toBe("EVL005");
+    expect(evl005ResourceBlockBodyRule.severity).toBe("error");
+    expect(evl005ResourceBlockBodyRule.category).toBe("correctness");
+  });
+
+  test("allows expression body", () => {
+    const ctx = createContext(`resource(Bucket, (props) => ({ name: "x" }));`);
+    expect(evl005ResourceBlockBodyRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("flags block body", () => {
+    const ctx = createContext(`resource(Bucket, (props) => { return { name: "x" }; });`);
+    const diags = evl005ResourceBlockBodyRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].ruleId).toBe("EVL005");
+    expect(diags[0].message).toContain("Block body");
+    expect(diags[0].message).toContain("expression body");
+  });
+
+  test("does not flag non-resource calls", () => {
+    const ctx = createContext(`someOther(Type, (props) => { return {}; });`);
+    expect(evl005ResourceBlockBodyRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("does not flag resource with no second argument", () => {
+    const ctx = createContext(`resource(Bucket);`);
+    expect(evl005ResourceBlockBodyRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("does not flag resource with non-arrow second argument", () => {
+    const ctx = createContext(`resource(Bucket, factoryFn);`);
+    expect(evl005ResourceBlockBodyRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("allows expression body with parenthesized object", () => {
+    const ctx = createContext(`resource(Bucket, (props, siblings) => ({ name: siblings.other.arn }));`);
+    expect(evl005ResourceBlockBodyRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("flags multiple violations", () => {
+    const ctx = createContext(`
+      resource(Bucket, (p) => { return {}; });
+      resource(Role, (p) => { return {}; });
+    `);
+    expect(evl005ResourceBlockBodyRule.check(ctx)).toHaveLength(2);
+  });
+});

package/src/lint/rules/evl005-resource-block-body.ts

@@ -0,0 +1,49 @@
+import * as ts from "typescript";
+import type { LintRule, LintContext, LintDiagnostic } from "../rule";
+
+/**
+ * EVL005: Block Body in resource() Callback
+ *
+ * The second argument to resource() must be an arrow function with an
+ * expression body: (props) => ({...}). Block bodies are not allowed
+ * because the evaluator expects an expression, not statements.
+ */
+
+function checkNode(node: ts.Node, context: LintContext, diagnostics: LintDiagnostic[]): void {
+  if (
+    ts.isCallExpression(node) &&
+    ts.isIdentifier(node.expression) &&
+    node.expression.text === "resource"
+  ) {
+    // resource(Type, (props) => ({ ... })) — second arg is the factory
+    const factory = node.arguments[1];
+    if (factory && ts.isArrowFunction(factory)) {
+      if (ts.isBlock(factory.body)) {
+        const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(
+          factory.body.getStart(context.sourceFile),
+        );
+        diagnostics.push({
+          file: context.filePath,
+          line: line + 1,
+          column: character + 1,
+          ruleId: "EVL005",
+          severity: "error",
+          message: "Block body in resource() callback — use expression body: (props) => ({...})",
+        });
+      }
+    }
+  }
+
+  ts.forEachChild(node, (child) => checkNode(child, context, diagnostics));
+}
+
+export const evl005ResourceBlockBodyRule: LintRule = {
+  id: "EVL005",
+  severity: "error",
+  category: "correctness",
+  check(context: LintContext): LintDiagnostic[] {
+    const diagnostics: LintDiagnostic[] = [];
+    checkNode(context.sourceFile, context, diagnostics);
+    return diagnostics;
+  },
+};

package/src/lint/rules/evl006-barrel-usage.test.ts

@@ -0,0 +1,63 @@
+import { describe, test, expect } from "bun:test";
+import * as ts from "typescript";
+import { evl006BarrelUsageRule } from "./evl006-barrel-usage";
+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("EVL006: barrel-usage", () => {
+  test("rule metadata", () => {
+    expect(evl006BarrelUsageRule.id).toBe("EVL006");
+    expect(evl006BarrelUsageRule.severity).toBe("error");
+    expect(evl006BarrelUsageRule.category).toBe("correctness");
+  });
+
+  test("allows correct barrel usage", () => {
+    const ctx = createContext(`export const $ = barrel(import.meta.dir);`);
+    expect(evl006BarrelUsageRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("flags string literal argument", () => {
+    const ctx = createContext(`export const $ = barrel("./src");`);
+    const diags = evl006BarrelUsageRule.check(ctx);
+    expect(diags.some((d) => d.message.includes("import.meta.dir"))).toBe(true);
+  });
+
+  test("flags variable argument", () => {
+    const ctx = createContext(`export const $ = barrel(myDir);`);
+    const diags = evl006BarrelUsageRule.check(ctx);
+    expect(diags.some((d) => d.message.includes("import.meta.dir"))).toBe(true);
+  });
+
+  test("flags non-exported barrel", () => {
+    const ctx = createContext(`const $ = barrel(import.meta.dir);`);
+    const diags = evl006BarrelUsageRule.check(ctx);
+    expect(diags.some((d) => d.message.includes("export const $"))).toBe(true);
+  });
+
+  test("flags barrel not assigned to $", () => {
+    const ctx = createContext(`export const myBarrel = barrel(import.meta.dir);`);
+    const diags = evl006BarrelUsageRule.check(ctx);
+    expect(diags.some((d) => d.message.includes("export const $"))).toBe(true);
+  });
+
+  test("flags let instead of const", () => {
+    const ctx = createContext(`export let $ = barrel(import.meta.dir);`);
+    const diags = evl006BarrelUsageRule.check(ctx);
+    expect(diags.some((d) => d.message.includes("export const $"))).toBe(true);
+  });
+
+  test("does not flag non-barrel calls", () => {
+    const ctx = createContext(`export const x = someFunction(import.meta.dir);`);
+    expect(evl006BarrelUsageRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("flags no arguments", () => {
+    const ctx = createContext(`export const $ = barrel();`);
+    const diags = evl006BarrelUsageRule.check(ctx);
+    expect(diags.some((d) => d.message.includes("import.meta.dir"))).toBe(true);
+  });
+});

package/src/lint/rules/evl006-barrel-usage.ts

@@ -0,0 +1,95 @@
+import * as ts from "typescript";
+import type { LintRule, LintContext, LintDiagnostic } from "../rule";
+
+/**
+ * EVL006: Incorrect barrel() Usage
+ *
+ * Two constraints:
+ * 1. The argument to barrel() must be import.meta.dir
+ * 2. The call must be part of: export const $ = barrel(import.meta.dir)
+ */
+
+function isImportMetaDir(node: ts.Node): boolean {
+  // import.meta.dir is a PropertyAccessExpression: (import.meta).dir
+  if (
+    ts.isPropertyAccessExpression(node) &&
+    node.name.text === "dir" &&
+    ts.isMetaProperty(node.expression) &&
+    node.expression.keywordToken === ts.SyntaxKind.ImportKeyword &&
+    node.expression.name.text === "meta"
+  ) {
+    return true;
+  }
+  return false;
+}
+
+function checkNode(node: ts.Node, context: LintContext, diagnostics: LintDiagnostic[]): void {
+  if (
+    ts.isCallExpression(node) &&
+    ts.isIdentifier(node.expression) &&
+    node.expression.text === "barrel"
+  ) {
+    // Check constraint 1: argument must be import.meta.dir
+    const arg = node.arguments[0];
+    if (!arg || !isImportMetaDir(arg)) {
+      const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(
+        node.getStart(context.sourceFile),
+      );
+      diagnostics.push({
+        file: context.filePath,
+        line: line + 1,
+        column: character + 1,
+        ruleId: "EVL006",
+        severity: "error",
+        message: "barrel() argument must be import.meta.dir",
+      });
+    }
+
+    // Check constraint 2: must be export const $ = barrel(...)
+    let isValidExport = false;
+    const parent = node.parent;
+    if (parent && ts.isVariableDeclaration(parent)) {
+      if (ts.isIdentifier(parent.name) && parent.name.text === "$") {
+        const declList = parent.parent;
+        if (declList && ts.isVariableDeclarationList(declList)) {
+          const stmt = declList.parent;
+          if (
+            stmt &&
+            ts.isVariableStatement(stmt) &&
+            stmt.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) &&
+            (declList.flags & ts.NodeFlags.Const) !== 0
+          ) {
+            isValidExport = true;
+          }
+        }
+      }
+    }
+
+    if (!isValidExport) {
+      const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(
+        node.getStart(context.sourceFile),
+      );
+      diagnostics.push({
+        file: context.filePath,
+        line: line + 1,
+        column: character + 1,
+        ruleId: "EVL006",
+        severity: "error",
+        message: "barrel() must be used as: export const $ = barrel(import.meta.dir)",
+      });
+    }
+  }
+
+  ts.forEachChild(node, (child) => checkNode(child, context, diagnostics));
+}
+
+export const evl006BarrelUsageRule: LintRule = {
+  id: "EVL006",
+  severity: "error",
+  category: "correctness",
+  check(context: LintContext): LintDiagnostic[] {
+    const diagnostics: LintDiagnostic[] = [];
+    checkNode(context.sourceFile, context, diagnostics);
+    return diagnostics;
+  },
+};

package/src/lint/rules/evl007-invalid-siblings.test.ts

@@ -0,0 +1,87 @@
+import { describe, test, expect } from "bun:test";
+import * as ts from "typescript";
+import { evl007InvalidSiblingsRule } from "./evl007-invalid-siblings";
+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("EVL007: invalid-siblings", () => {
+  test("rule metadata", () => {
+    expect(evl007InvalidSiblingsRule.id).toBe("EVL007");
+    expect(evl007InvalidSiblingsRule.severity).toBe("error");
+    expect(evl007InvalidSiblingsRule.category).toBe("correctness");
+  });
+
+  test("allows valid sibling access", () => {
+    const ctx = createContext(`
+      Composite((props) => ({
+        bucket: resource(Bucket, () => ({ name: "x" })),
+        role: resource(Role, (p, siblings) => ({ bucketArn: siblings.bucket.arn })),
+      }));
+    `);
+    expect(evl007InvalidSiblingsRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("flags invalid sibling key", () => {
+    const ctx = createContext(`
+      Composite((props) => ({
+        bucket: resource(Bucket, () => ({ name: "x" })),
+        role: resource(Role, (p, siblings) => ({ bucketArn: siblings.nonExistent.arn })),
+      }));
+    `);
+    const diags = evl007InvalidSiblingsRule.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].ruleId).toBe("EVL007");
+    expect(diags[0].message).toContain("nonExistent");
+    expect(diags[0].message).toContain("not a member");
+  });
+
+  test("allows access to all defined members", () => {
+    const ctx = createContext(`
+      Composite((props) => ({
+        bucket: resource(Bucket, () => ({ name: "x" })),
+        table: resource(Table, () => ({ name: "y" })),
+        role: resource(Role, (p, siblings) => ({
+          bucketArn: siblings.bucket.arn,
+          tableArn: siblings.table.arn,
+        })),
+      }));
+    `);
+    expect(evl007InvalidSiblingsRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("does not flag when no siblings parameter", () => {
+    const ctx = createContext(`
+      Composite((props) => ({
+        bucket: resource(Bucket, (p) => ({ name: "x" })),
+      }));
+    `);
+    expect(evl007InvalidSiblingsRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("does not flag non-Composite calls", () => {
+    const ctx = createContext(`
+      someFunction((props) => ({
+        bucket: resource(Bucket, (p, siblings) => ({ x: siblings.nonExistent })),
+      }));
+    `);
+    expect(evl007InvalidSiblingsRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("flags multiple invalid accesses", () => {
+    const ctx = createContext(`
+      Composite((props) => ({
+        bucket: resource(Bucket, () => ({ name: "x" })),
+        role: resource(Role, (p, siblings) => ({
+          a: siblings.missing1.arn,
+          b: siblings.missing2.arn,
+        })),
+      }));
+    `);
+    const diags = evl007InvalidSiblingsRule.check(ctx);
+    expect(diags).toHaveLength(2);
+  });
+});