@intentius/chant 0.0.4 → 0.0.8

package/src/lint/rules/evl008-unresolvable-barrel-ref.test.ts

@@ -1,118 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import * as ts from "typescript";
-import { evl008UnresolvableBarrelRefRule } from "./evl008-unresolvable-barrel-ref";
-import type { LintContext } from "../rule";
-
-function createContext(
-  code: string,
-  barrelExports?: Set<string>,
-  filePath = "test.ts",
-): LintContext {
-  const sourceFile = ts.createSourceFile(filePath, code, ts.ScriptTarget.Latest, true);
-  return { sourceFile, entities: [], filePath, lexicon: undefined, barrelExports };
-}
-
-describe("EVL008: unresolvable-barrel-ref", () => {
-  test("rule metadata", () => {
-    expect(evl008UnresolvableBarrelRefRule.id).toBe("EVL008");
-    expect(evl008UnresolvableBarrelRefRule.severity).toBe("error");
-    expect(evl008UnresolvableBarrelRefRule.category).toBe("correctness");
-  });
-
-  test("skips when no barrelExports provided", () => {
-    const ctx = createContext(`
-      export const $ = barrel(import.meta.dir);
-      const x = $.myBucket;
-    `);
-    expect(evl008UnresolvableBarrelRefRule.check(ctx)).toHaveLength(0);
-  });
-
-  test("allows valid direct barrel reference", () => {
-    const exports = new Set(["myBucket", "myRole"]);
-    const ctx = createContext(
-      `
-      export const $ = barrel(import.meta.dir);
-      const x = $.myBucket;
-    `,
-      exports,
-    );
-    expect(evl008UnresolvableBarrelRefRule.check(ctx)).toHaveLength(0);
-  });
-
-  test("flags invalid direct barrel reference", () => {
-    const exports = new Set(["myBucket", "myRole"]);
-    const ctx = createContext(
-      `
-      export const $ = barrel(import.meta.dir);
-      const x = $.nonExistent;
-    `,
-      exports,
-    );
-    const diags = evl008UnresolvableBarrelRefRule.check(ctx);
-    expect(diags).toHaveLength(1);
-    expect(diags[0].ruleId).toBe("EVL008");
-    expect(diags[0].message).toContain("nonExistent");
-    expect(diags[0].message).toContain("not exported");
-  });
-
-  test("allows valid namespace barrel reference", () => {
-    const exports = new Set(["myBucket"]);
-    const ctx = createContext(
-      `
-      import * as _ from "./_";
-      const x = _.$.myBucket;
-    `,
-      exports,
-    );
-    expect(evl008UnresolvableBarrelRefRule.check(ctx)).toHaveLength(0);
-  });
-
-  test("flags invalid namespace barrel reference", () => {
-    const exports = new Set(["myBucket"]);
-    const ctx = createContext(
-      `
-      import * as _ from "./_";
-      const x = _.$.missing;
-    `,
-      exports,
-    );
-    const diags = evl008UnresolvableBarrelRefRule.check(ctx);
-    expect(diags).toHaveLength(1);
-    expect(diags[0].message).toContain("missing");
-  });
-
-  test("does not flag when no barrel usage in file", () => {
-    const exports = new Set(["myBucket"]);
-    const ctx = createContext(`const x = someObj.prop;`, exports);
-    expect(evl008UnresolvableBarrelRefRule.check(ctx)).toHaveLength(0);
-  });
-
-  test("flags multiple invalid references", () => {
-    const exports = new Set(["myBucket"]);
-    const ctx = createContext(
-      `
-      export const $ = barrel(import.meta.dir);
-      const a = $.missing1;
-      const b = $.missing2;
-    `,
-      exports,
-    );
-    expect(evl008UnresolvableBarrelRefRule.check(ctx)).toHaveLength(2);
-  });
-
-  test("handles mixed valid and invalid", () => {
-    const exports = new Set(["bucket", "role"]);
-    const ctx = createContext(
-      `
-      export const $ = barrel(import.meta.dir);
-      const a = $.bucket;
-      const b = $.missing;
-      const c = $.role;
-    `,
-      exports,
-    );
-    const diags = evl008UnresolvableBarrelRefRule.check(ctx);
-    expect(diags).toHaveLength(1);
-    expect(diags[0].message).toContain("missing");
-  });
-});

package/src/lint/rules/evl008-unresolvable-barrel-ref.ts

@@ -1,140 +0,0 @@
-import * as ts from "typescript";
-import type { LintRule, LintContext, LintDiagnostic } from "../rule";
-
-/**
- * EVL008: Unresolvable Barrel Reference
- *
- * When accessing the barrel variable (e.g., $.resourceName), the
- * referenced name must exist in the project's barrel exports.
- * Requires barrelExports on LintContext.
- */
-
-/**
- * Find the barrel variable name in a source file.
- *
- * Patterns:
- * - `export const $ = barrel(...)` → "$"
- * - `import * as _ from "./_"` then `_.$` → "$" accessed via "_"
- */
-function findBarrelVarName(sourceFile: ts.SourceFile): string | null {
-  for (const stmt of sourceFile.statements) {
-    // export const $ = barrel(...)
-    if (
-      ts.isVariableStatement(stmt) &&
-      stmt.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)
-    ) {
-      for (const decl of stmt.declarationList.declarations) {
-        if (
-          ts.isIdentifier(decl.name) &&
-          decl.name.text === "$" &&
-          decl.initializer &&
-          ts.isCallExpression(decl.initializer) &&
-          ts.isIdentifier(decl.initializer.expression) &&
-          decl.initializer.expression.text === "barrel"
-        ) {
-          return "$";
-        }
-      }
-    }
-  }
-  return null;
-}
-
-/**
- * Find namespace imports that re-export the barrel.
- * e.g., `import * as _ from "./_"` — then _.$ accesses the barrel.
- */
-function findBarrelNamespaceImports(sourceFile: ts.SourceFile): string[] {
-  const names: string[] = [];
-  for (const stmt of sourceFile.statements) {
-    if (
-      ts.isImportDeclaration(stmt) &&
-      stmt.importClause?.namedBindings &&
-      ts.isNamespaceImport(stmt.importClause.namedBindings) &&
-      stmt.moduleSpecifier &&
-      ts.isStringLiteral(stmt.moduleSpecifier)
-    ) {
-      const spec = stmt.moduleSpecifier.text;
-      // Convention: barrel files are "_" or "./_"
-      if (spec === "./_" || spec === "_") {
-        names.push(stmt.importClause.namedBindings.name.text);
-      }
-    }
-  }
-  return names;
-}
-
-function checkNode(
-  node: ts.Node,
-  context: LintContext,
-  diagnostics: LintDiagnostic[],
-  barrelVar: string | null,
-  namespaceImports: string[],
-): void {
-  if (ts.isPropertyAccessExpression(node)) {
-    const accessedName = node.name.text;
-
-    // Direct barrel access: $.resourceName
-    if (barrelVar && ts.isIdentifier(node.expression) && node.expression.text === barrelVar) {
-      if (context.barrelExports && !context.barrelExports.has(accessedName)) {
-        const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(
-          node.getStart(context.sourceFile),
-        );
-        diagnostics.push({
-          file: context.filePath,
-          line: line + 1,
-          column: character + 1,
-          ruleId: "EVL008",
-          severity: "error",
-          message: `Unresolvable barrel reference — "${accessedName}" is not exported from the barrel`,
-        });
-      }
-    }
-
-    // Namespace access: _.$.resourceName
-    if (
-      ts.isPropertyAccessExpression(node.expression) &&
-      ts.isIdentifier(node.expression.expression) &&
-      namespaceImports.includes(node.expression.expression.text) &&
-      node.expression.name.text === "$"
-    ) {
-      if (context.barrelExports && !context.barrelExports.has(accessedName)) {
-        const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(
-          node.getStart(context.sourceFile),
-        );
-        diagnostics.push({
-          file: context.filePath,
-          line: line + 1,
-          column: character + 1,
-          ruleId: "EVL008",
-          severity: "error",
-          message: `Unresolvable barrel reference — "${accessedName}" is not exported from the barrel`,
-        });
-      }
-    }
-  }
-
-  ts.forEachChild(node, (child) =>
-    checkNode(child, context, diagnostics, barrelVar, namespaceImports),
-  );
-}
-
-export const evl008UnresolvableBarrelRefRule: LintRule = {
-  id: "EVL008",
-  severity: "error",
-  category: "correctness",
-  check(context: LintContext): LintDiagnostic[] {
-    // Skip if no barrel exports data is available
-    if (!context.barrelExports) return [];
-
-    const barrelVar = findBarrelVarName(context.sourceFile);
-    const namespaceImports = findBarrelNamespaceImports(context.sourceFile);
-
-    // If this file doesn't use the barrel, nothing to check
-    if (!barrelVar && namespaceImports.length === 0) return [];
-
-    const diagnostics: LintDiagnostic[] = [];
-    checkNode(context.sourceFile, context, diagnostics, barrelVar, namespaceImports);
-    return diagnostics;
-  },
-};

package/src/lint/rules/prefer-namespace-import.test.ts

@@ -1,102 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import * as ts from "typescript";
-import { preferNamespaceImportRule } from "./prefer-namespace-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("COR006: prefer-namespace-import", () => {
-  test("rule metadata", () => {
-    expect(preferNamespaceImportRule.id).toBe("COR006");
-    expect(preferNamespaceImportRule.severity).toBe("error");
-    expect(preferNamespaceImportRule.category).toBe("style");
-  });
-
-  test("flags named import from @intentius/chant* package", () => {
-    const code = `import { Bucket } from "@intentius/chant-lexicon-testdom";`;
-    const context = createContext(code);
-    const diagnostics = preferNamespaceImportRule.check(context);
-
-    expect(diagnostics).toHaveLength(1);
-    expect(diagnostics[0].ruleId).toBe("COR006");
-    expect(diagnostics[0].severity).toBe("error");
-    expect(diagnostics[0].message).toBe(
-      `Use namespace import for @intentius/chant-lexicon-testdom — replace with: import * as testdom from "@intentius/chant-lexicon-testdom"`
-    );
-  });
-
-  test("allows namespace import from @intentius/chant* package", () => {
-    const code = `import * as testdom from "@intentius/chant-lexicon-testdom";`;
-    const context = createContext(code);
-    const diagnostics = preferNamespaceImportRule.check(context);
-    expect(diagnostics).toHaveLength(0);
-  });
-
-  test("allows type-only import from @intentius/chant* package", () => {
-    const code = `import type { Declarable } from "@intentius/chant";`;
-    const context = createContext(code);
-    const diagnostics = preferNamespaceImportRule.check(context);
-    expect(diagnostics).toHaveLength(0);
-  });
-
-  test("does not flag imports from non-@intentius/chant packages", () => {
-    const code = `import { useState } from "react";`;
-    const context = createContext(code);
-    const diagnostics = preferNamespaceImportRule.check(context);
-    expect(diagnostics).toHaveLength(0);
-  });
-
-  test("does not flag imports from relative paths", () => {
-    const code = `import { helper } from "./utils";`;
-    const context = createContext(code);
-    const diagnostics = preferNamespaceImportRule.check(context);
-    expect(diagnostics).toHaveLength(0);
-  });
-
-  test("derives alias from package name", () => {
-    const code = `import { Config } from "@intentius/chant";`;
-    const context = createContext(code);
-    const diagnostics = preferNamespaceImportRule.check(context);
-
-    expect(diagnostics).toHaveLength(1);
-    expect(diagnostics[0].message).toContain("import * as core");
-  });
-
-  test("flags multiple named imports from different @intentius/chant packages", () => {
-    const code = `
-import { Bucket } from "@intentius/chant-lexicon-testdom";
-import { Config } from "@intentius/chant";
-`;
-    const context = createContext(code);
-    const diagnostics = preferNamespaceImportRule.check(context);
-
-    expect(diagnostics).toHaveLength(2);
-    expect(diagnostics[0].message).toContain("@intentius/chant-lexicon-testdom");
-    expect(diagnostics[1].message).toContain("@intentius/chant");
-  });
-
-  test("reports correct line and column numbers", () => {
-    const code = `import { Bucket } from "@intentius/chant-lexicon-testdom";`;
-    const context = createContext(code);
-    const diagnostics = preferNamespaceImportRule.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");
-  });
-});

package/src/lint/rules/prefer-namespace-import.ts

@@ -1,63 +0,0 @@
-import * as ts from "typescript";
-import type { LintRule, LintContext, LintDiagnostic } from "../rule";
-
-/**
- * COR006: prefer-namespace-import
- *
- * Enforce `import * as pkg` for `@intentius/chant*` package imports.
- *
- * Triggers on: import { Bucket } from "@intentius/chant-lexicon-<name>"
- * OK: import * as <name> from "@intentius/chant-lexicon-<name>"
- * OK: import type { Declarable } from "@intentius/chant"
- */
-
-function checkNode(node: ts.Node, context: LintContext, diagnostics: LintDiagnostic[]): void {
-  if (ts.isImportDeclaration(node)) {
-    const moduleSpecifier = node.moduleSpecifier;
-    if (!ts.isStringLiteral(moduleSpecifier)) return;
-
-    const modulePath = moduleSpecifier.text;
-    if (!modulePath.startsWith("@intentius/chant") && !modulePath.startsWith("@intentius/chant-lexicon-")) return;
-
-    // Skip type-only imports: import type { X } from "..."
-    if (node.importClause?.isTypeOnly) return;
-
-    const importClause = node.importClause;
-    if (!importClause?.namedBindings) return;
-
-    // Flag named imports (not namespace imports)
-    if (ts.isNamedImports(importClause.namedBindings)) {
-      const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(
-        node.getStart(context.sourceFile)
-      );
-
-      const pkgName = modulePath === "@intentius/chant"
-        ? "core"
-        : modulePath.startsWith("@intentius/chant-lexicon-")
-          ? modulePath.replace("@intentius/chant-lexicon-", "")
-          : modulePath.replace("@intentius/chant-", "");
-
-      diagnostics.push({
-        file: context.filePath,
-        line: line + 1,
-        column: character + 1,
-        ruleId: "COR006",
-        severity: "error",
-        message: `Use namespace import for ${modulePath} — replace with: import * as ${pkgName} from "${modulePath}"`,
-      });
-    }
-  }
-
-  ts.forEachChild(node, child => checkNode(child, context, diagnostics));
-}
-
-export const preferNamespaceImportRule: LintRule = {
-  id: "COR006",
-  severity: "error",
-  category: "style",
-  check(context: LintContext): LintDiagnostic[] {
-    const diagnostics: LintDiagnostic[] = [];
-    checkNode(context.sourceFile, context, diagnostics);
-    return diagnostics;
-  },
-};

package/src/lint/rules/stale-barrel-types.ts

@@ -1,60 +0,0 @@
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import type { LintRule, LintContext, LintDiagnostic } from "../rule";
-import { generateBarrelTypes } from "../../project/sync";
-
-/**
- * COR016: stale-barrel-types
- *
- * Checks that `_.d.ts` barrel type declarations are up-to-date with
- * the current project scan. Fires only on `_.ts` barrel files.
- *
- * When --fix is used, the fix writes the expected content to `_.d.ts`.
- */
-export const staleBarrelTypesRule: LintRule = {
-  id: "COR016",
-  severity: "warning",
-  category: "correctness",
-  check(context: LintContext): LintDiagnostic[] {
-    // Only fire on _.ts barrel files
-    if (!context.filePath.endsWith("/_.ts") && context.filePath !== "_.ts") {
-      return [];
-    }
-
-    // Requires projectScan
-    if (!context.projectScan) return [];
-
-    const expected = generateBarrelTypes(context.projectScan);
-    const dtsPath = join(dirname(context.filePath), "_.d.ts");
-
-    let existing: string | undefined;
-    try {
-      existing = readFileSync(dtsPath, "utf-8");
-    } catch {
-      // File doesn't exist
-    }
-
-    if (existing === expected) return [];
-
-    const message = existing === undefined
-      ? "Missing _.d.ts barrel type declarations. Run 'chant lint --fix' to generate."
-      : "Stale _.d.ts barrel type declarations. Run 'chant lint --fix' to regenerate.";
-
-    return [
-      {
-        file: context.filePath,
-        line: 1,
-        column: 1,
-        ruleId: "COR016",
-        severity: "warning",
-        message,
-        fix: {
-          range: [0, 0],
-          replacement: "",
-          kind: "write-file",
-          params: { path: dtsPath, content: expected },
-        },
-      },
-    ];
-  },
-};

package/src/project/scan.test.ts

@@ -1,178 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { scanProject } from "./scan";
-import { withTestDir } from "@intentius/chant-test-utils";
-import { writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
-describe("scanProject", () => {
-  test("finds barrel and extracts lexicon package", async () => {
-    await withTestDir(async (dir) => {
-      await writeFile(
-        join(dir, "_.ts"),
-        `export * from "@intentius/chant-lexicon-testdom";\nexport * from "./storage";\n`,
-      );
-      await writeFile(
-        join(dir, "storage.ts"),
-        `import * as td from "@intentius/chant-lexicon-testdom";\nexport const bucket = new td.Bucket({});\n`,
-      );
-
-      const scan = scanProject(dir);
-      expect(scan.barrelPath).toBe(join(dir, "_.ts"));
-      expect(scan.lexiconPackage).toBe("@intentius/chant-lexicon-testdom");
-    });
-  });
-
-  test("collects exports from sibling files", async () => {
-    await withTestDir(async (dir) => {
-      await writeFile(
-        join(dir, "_.ts"),
-        `export * from "@intentius/chant-lexicon-testdom";\n`,
-      );
-      await writeFile(
-        join(dir, "storage.ts"),
-        `import * as td from "@intentius/chant-lexicon-testdom";\nexport const dataBucket = new td.Bucket({});\nexport const logsBucket = new td.Bucket({});\n`,
-      );
-      await writeFile(
-        join(dir, "compute.ts"),
-        `import * as td from "@intentius/chant-lexicon-testdom";\nexport const handler = new td.Function({});\n`,
-      );
-
-      const scan = scanProject(dir);
-      expect(scan.exports).toHaveLength(3);
-      const names = scan.exports.map((e) => e.name);
-      expect(names).toContain("dataBucket");
-      expect(names).toContain("logsBucket");
-      expect(names).toContain("handler");
-    });
-  });
-
-  test("infers class names from new X.ClassName(...) patterns", async () => {
-    await withTestDir(async (dir) => {
-      await writeFile(
-        join(dir, "_.ts"),
-        `export * from "@intentius/chant-lexicon-testdom";\n`,
-      );
-      await writeFile(
-        join(dir, "resources.ts"),
-        [
-          `import * as td from "@intentius/chant-lexicon-testdom";`,
-          `export const bucket = new td.Bucket({});`,
-          `export const role = new td.Role({});`,
-          `export const fn = new td.Function({});`,
-        ].join("\n"),
-      );
-
-      const scan = scanProject(dir);
-      expect(scan.exports).toHaveLength(3);
-
-      const bucket = scan.exports.find((e) => e.name === "bucket");
-      expect(bucket?.className).toBe("Bucket");
-
-      const role = scan.exports.find((e) => e.name === "role");
-      expect(role?.className).toBe("Role");
-
-      const fn = scan.exports.find((e) => e.name === "fn");
-      expect(fn?.className).toBe("Function");
-    });
-  });
-
-  test("infers class names from type annotations", async () => {
-    await withTestDir(async (dir) => {
-      await writeFile(
-        join(dir, "_.ts"),
-        `export * from "@intentius/chant-lexicon-testdom";\n`,
-      );
-      await writeFile(
-        join(dir, "config.ts"),
-        [
-          `import * as td from "@intentius/chant-lexicon-testdom";`,
-          `export const encryption: td.ServerSideEncryptionByDefault = { sseAlgorithm: "AES256" };`,
-          `export const versioning: td.VersioningConfiguration = { status: "Enabled" };`,
-        ].join("\n"),
-      );
-
-      const scan = scanProject(dir);
-      expect(scan.exports).toHaveLength(2);
-
-      const encryption = scan.exports.find((e) => e.name === "encryption");
-      expect(encryption?.className).toBe("ServerSideEncryptionByDefault");
-
-      const versioning = scan.exports.find((e) => e.name === "versioning");
-      expect(versioning?.className).toBe("VersioningConfiguration");
-    });
-  });
-
-  test("excludes barrel, test files, and underscore-prefixed files", async () => {
-    await withTestDir(async (dir) => {
-      await writeFile(
-        join(dir, "_.ts"),
-        `export * from "@intentius/chant-lexicon-testdom";\n`,
-      );
-      await writeFile(
-        join(dir, "_internal.ts"),
-        `export const secret = "hidden";\n`,
-      );
-      await writeFile(
-        join(dir, "app.test.ts"),
-        `import { test } from "bun:test";\ntest("passes", () => {});\n`,
-      );
-      await writeFile(
-        join(dir, "app.spec.ts"),
-        `import { test } from "bun:test";\ntest("passes", () => {});\n`,
-      );
-      await writeFile(
-        join(dir, "app.ts"),
-        `export const app = "hello";\n`,
-      );
-
-      const scan = scanProject(dir);
-      expect(scan.exports).toHaveLength(1);
-      expect(scan.exports[0].name).toBe("app");
-    });
-  });
-
-  test("throws on missing barrel", async () => {
-    await withTestDir(async (dir) => {
-      expect(() => scanProject(dir)).toThrow("No barrel file found");
-    });
-  });
-
-  test("returns empty className for exports without recognizable patterns", async () => {
-    await withTestDir(async (dir) => {
-      await writeFile(
-        join(dir, "_.ts"),
-        `export * from "@intentius/chant-lexicon-testdom";\n`,
-      );
-      await writeFile(
-        join(dir, "utils.ts"),
-        `export const greeting = "hello";\nexport const count = 42;\n`,
-      );
-
-      const scan = scanProject(dir);
-      expect(scan.exports).toHaveLength(2);
-      for (const exp of scan.exports) {
-        expect(exp.className).toBe("");
-      }
-    });
-  });
-
-  test("infers class names from new _.ClassName(...) patterns", async () => {
-    await withTestDir(async (dir) => {
-      await writeFile(
-        join(dir, "_.ts"),
-        `export * from "@intentius/chant-lexicon-testdom";\n`,
-      );
-      await writeFile(
-        join(dir, "resources.ts"),
-        [
-          `import * as _ from "./_";`,
-          `export const bucket = new _.Bucket({});`,
-        ].join("\n"),
-      );
-
-      const scan = scanProject(dir);
-      expect(scan.exports).toHaveLength(1);
-      expect(scan.exports[0].className).toBe("Bucket");
-    });
-  });
-});