@alexgorbatchev/typescript-ai-policy 0.1.0

package/src/oxlint/rules/no-non-running-tests.ts

@@ -0,0 +1,72 @@
+import type { AstExpression, RuleModule } from "./types.ts";
+import { isTestFile } from "./helpers.ts";
+
+type CalleeMember = {
+  objectName: string;
+  propertyName: string;
+};
+
+const TEST_FUNCTION_NAMES = new Set(["describe", "it", "test"]);
+const BLOCKED_TEST_MODIFIERS = new Set(["if", "skipIf", "todo", "todoIf"]);
+
+function readCalleeMember(node: AstExpression): CalleeMember | null {
+  if (
+    node.type !== "MemberExpression" ||
+    node.computed ||
+    node.object.type !== "Identifier" ||
+    node.property.type !== "Identifier"
+  ) {
+    return null;
+  }
+
+  return {
+    objectName: node.object.name,
+    propertyName: node.property.name,
+  };
+}
+
+const noNonRunningTestsRule: RuleModule = {
+  meta: {
+    type: "problem" as const,
+    docs: {
+      description: "Ban non-running test modifiers that suppress or gate test execution",
+    },
+    schema: [],
+    messages: {
+      forbiddenModifier:
+        'Remove "{{ fullName }}". Committed tests must always run, so use plain describe(...), it(...), or test(...) instead of gated, skipped, or todo variants.',
+    },
+  },
+  create(context) {
+    if (!isTestFile(context.filename)) {
+      return {};
+    }
+
+    return {
+      CallExpression(node) {
+        const calleeMember = readCalleeMember(node.callee);
+        if (!calleeMember) {
+          return;
+        }
+
+        if (!TEST_FUNCTION_NAMES.has(calleeMember.objectName)) {
+          return;
+        }
+
+        if (!BLOCKED_TEST_MODIFIERS.has(calleeMember.propertyName)) {
+          return;
+        }
+
+        context.report({
+          node,
+          messageId: "forbiddenModifier",
+          data: {
+            fullName: `${calleeMember.objectName}.${calleeMember.propertyName}`,
+          },
+        });
+      },
+    };
+  },
+};
+
+export default noNonRunningTestsRule;

package/src/oxlint/rules/no-react-create-element.ts

@@ -0,0 +1,59 @@
+import type { RuleModule } from "./types.ts";
+
+const noReactCreateElementRule: RuleModule = {
+  meta: {
+    type: "problem" as const,
+    docs: {
+      description: "Ban React createElement in regular application code; use JSX instead",
+    },
+    schema: [],
+    messages: {
+      noImportedCreateElement:
+        'Remove the createElement import from "react" and rewrite the rendered output as JSX syntax.',
+      noReactCreateElement: "Replace React.createElement(...) with equivalent JSX syntax.",
+    },
+  },
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        if (node.source?.value !== "react") {
+          return;
+        }
+
+        node.specifiers.forEach((specifier) => {
+          if (specifier.type !== "ImportSpecifier") {
+            return;
+          }
+
+          if (specifier.imported.type !== "Identifier" || specifier.imported.name !== "createElement") {
+            return;
+          }
+
+          context.report({
+            node: specifier,
+            messageId: "noImportedCreateElement",
+          });
+        });
+      },
+      CallExpression(node) {
+        if (
+          node.callee.type !== "MemberExpression" ||
+          node.callee.computed ||
+          node.callee.object.type !== "Identifier" ||
+          node.callee.object.name !== "React" ||
+          node.callee.property.type !== "Identifier" ||
+          node.callee.property.name !== "createElement"
+        ) {
+          return;
+        }
+
+        context.report({
+          node,
+          messageId: "noReactCreateElement",
+        });
+      },
+    };
+  },
+};
+
+export default noReactCreateElementRule;

package/src/oxlint/rules/no-test-file-exports.ts

@@ -0,0 +1,52 @@
+import type { RuleModule } from "./types.ts";
+import { getBaseName } from "./helpers.ts";
+
+const TEST_FILE_NAME_PATTERN = /\.test\.tsx?$/u;
+
+const noTestFileExportsRule: RuleModule = {
+  meta: {
+    type: "problem" as const,
+    docs: {
+      description: "Ban exports from .test.ts and .test.tsx files",
+    },
+    schema: [],
+    messages: {
+      unexpectedTestExport:
+        "Remove this export from the test file. Move shared test code into helpers.ts, fixtures.ts, or fixtures/ instead.",
+    },
+  },
+  create(context) {
+    if (!TEST_FILE_NAME_PATTERN.test(getBaseName(context.filename))) {
+      return {};
+    }
+
+    return {
+      ExportAllDeclaration(node) {
+        context.report({
+          node,
+          messageId: "unexpectedTestExport",
+        });
+      },
+      ExportDefaultDeclaration(node) {
+        context.report({
+          node,
+          messageId: "unexpectedTestExport",
+        });
+      },
+      ExportNamedDeclaration(node) {
+        context.report({
+          node,
+          messageId: "unexpectedTestExport",
+        });
+      },
+      TSExportAssignment(node) {
+        context.report({
+          node,
+          messageId: "unexpectedTestExport",
+        });
+      },
+    };
+  },
+};
+
+export default noTestFileExportsRule;

package/src/oxlint/rules/no-throw-in-tests.ts

@@ -0,0 +1,40 @@
+import type { RuleModule } from "./types.ts";
+import { isTestFile } from "./helpers.ts";
+
+const noThrowInTestsRule: RuleModule = {
+  meta: {
+    type: "problem" as const,
+    docs: {
+      description: 'Ban "throw new Error(...)" inside committed test files',
+    },
+    schema: [],
+    messages: {
+      forbiddenThrowNewError:
+        'Remove this "throw new Error(...)" from the test. Use assert(...) or assert.fail(...) from "node:assert" so failures stay explicit and deterministic.',
+    },
+  },
+  create(context) {
+    if (!isTestFile(context.filename)) {
+      return {};
+    }
+
+    return {
+      ThrowStatement(node) {
+        if (node.argument?.type !== "NewExpression") {
+          return;
+        }
+
+        if (node.argument.callee.type !== "Identifier" || node.argument.callee.name !== "Error") {
+          return;
+        }
+
+        context.report({
+          node,
+          messageId: "forbiddenThrowNewError",
+        });
+      },
+    };
+  },
+};
+
+export default noThrowInTestsRule;

package/src/oxlint/rules/no-type-exports-from-constants.ts

@@ -0,0 +1,97 @@
+import type { AstExportNamedDeclaration, AstExportSpecifier, RuleModule } from "./types.ts";
+import { hasBaseName, readDeclarationIdentifierNames, readLiteralStringValue } from "./helpers.ts";
+
+function readExportedSpecifierName(specifier: AstExportSpecifier): string {
+  if (specifier.exported.type === "Identifier") {
+    return specifier.exported.name;
+  }
+
+  return String(specifier.exported.value);
+}
+
+function isTypeExportSpecifier(specifier: AstExportSpecifier, exportDeclaration: AstExportNamedDeclaration): boolean {
+  return exportDeclaration.exportKind === "type" || specifier.exportKind === "type";
+}
+
+const noTypeExportsFromConstantsRule: RuleModule = {
+  meta: {
+    type: "problem" as const,
+    docs: {
+      description: 'Disallow exporting type-only API from files whose filename is "constants"',
+    },
+    schema: [],
+    messages: {
+      unexpectedTypeExport:
+        'Move exported type "{{ name }}" out of this "constants" file and into a sibling "types.ts" module. "constants.ts" must export runtime values only.',
+      unexpectedTypeExportAll:
+        'Do not re-export types from "{{ exportPath }}" through a "constants" file. Re-export them from a sibling "types.ts" module instead.',
+    },
+  },
+  create(context) {
+    if (!hasBaseName(context.filename, "constants")) {
+      return {};
+    }
+
+    return {
+      ExportAllDeclaration(node) {
+        if (node.exportKind !== "type") {
+          return;
+        }
+
+        context.report({
+          node,
+          messageId: "unexpectedTypeExportAll",
+          data: {
+            exportPath: readLiteralStringValue(node.source) ?? "this module",
+          },
+        });
+      },
+      ExportNamedDeclaration(node) {
+        if (node.declaration) {
+          if (node.exportKind !== "type") {
+            return;
+          }
+
+          const exportNames = readDeclarationIdentifierNames(node.declaration);
+          if (exportNames.length === 0) {
+            context.report({
+              node: node.declaration,
+              messageId: "unexpectedTypeExport",
+              data: {
+                name: "this binding",
+              },
+            });
+            return;
+          }
+
+          exportNames.forEach((name) => {
+            context.report({
+              node: node.declaration,
+              messageId: "unexpectedTypeExport",
+              data: {
+                name,
+              },
+            });
+          });
+          return;
+        }
+
+        node.specifiers.forEach((specifier) => {
+          if (!isTypeExportSpecifier(specifier, node)) {
+            return;
+          }
+
+          context.report({
+            node: specifier,
+            messageId: "unexpectedTypeExport",
+            data: {
+              name: readExportedSpecifierName(specifier),
+            },
+          });
+        });
+      },
+    };
+  },
+};
+
+export default noTypeExportsFromConstantsRule;

package/src/oxlint/rules/no-type-imports-from-constants.ts

@@ -0,0 +1,73 @@
+import type { AstImportClause, AstImportDeclaration, RuleModule } from "./types.ts";
+import { hasBaseName, readLiteralStringValue } from "./helpers.ts";
+
+function readImportBindingName(specifier: AstImportClause): string {
+  if (specifier.local?.type === "Identifier") {
+    return specifier.local.name;
+  }
+
+  return "this binding";
+}
+
+function isTypeImportSpecifier(specifier: AstImportClause, importDeclaration: AstImportDeclaration): boolean {
+  return (
+    importDeclaration.importKind === "type" || (specifier.type === "ImportSpecifier" && specifier.importKind === "type")
+  );
+}
+
+const noTypeImportsFromConstantsRule: RuleModule = {
+  meta: {
+    type: "problem" as const,
+    docs: {
+      description: 'Disallow type imports from modules whose filename is "constants"',
+    },
+    schema: [],
+    messages: {
+      unexpectedInlineTypeImport:
+        'Do not reference "{{ importPath }}" through a type import. Move that exported type into a sibling "types.ts" module instead.',
+      unexpectedTypeImport:
+        'Do not import type "{{ name }}" from "{{ importPath }}". Move that exported type into a sibling "types.ts" module instead.',
+    },
+  },
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        const importPath = readLiteralStringValue(node.source);
+        if (!importPath || !hasBaseName(importPath, "constants")) {
+          return;
+        }
+
+        node.specifiers.forEach((specifier) => {
+          if (!isTypeImportSpecifier(specifier, node)) {
+            return;
+          }
+
+          context.report({
+            node: specifier,
+            messageId: "unexpectedTypeImport",
+            data: {
+              name: readImportBindingName(specifier),
+              importPath,
+            },
+          });
+        });
+      },
+      TSImportType(node) {
+        const importPath = readLiteralStringValue(node.source);
+        if (!importPath || !hasBaseName(importPath, "constants")) {
+          return;
+        }
+
+        context.report({
+          node,
+          messageId: "unexpectedInlineTypeImport",
+          data: {
+            importPath,
+          },
+        });
+      },
+    };
+  },
+};
+
+export default noTypeImportsFromConstantsRule;

package/src/oxlint/rules/no-value-exports-from-types.ts

@@ -0,0 +1,115 @@
+import type { AstExportNamedDeclaration, AstExportSpecifier, RuleModule } from "./types.ts";
+import { hasBaseName, isTypeDeclaration, readDeclarationIdentifierNames, readLiteralStringValue } from "./helpers.ts";
+
+function readExportedSpecifierName(specifier: AstExportSpecifier): string {
+  if (specifier.exported.type === "Identifier") {
+    return specifier.exported.name;
+  }
+
+  return String(specifier.exported.value);
+}
+
+function isTypeOnlyExportSpecifier(
+  specifier: AstExportSpecifier,
+  exportDeclaration: AstExportNamedDeclaration,
+): boolean {
+  return exportDeclaration.exportKind === "type" || specifier.exportKind === "type";
+}
+
+const noValueExportsFromTypesRule: RuleModule = {
+  meta: {
+    type: "problem" as const,
+    docs: {
+      description: 'Disallow value exports from files whose filename is "types"',
+    },
+    schema: [],
+    messages: {
+      unexpectedDefaultExport: 'Remove this default export from the "types" file. "types.ts" may export types only.',
+      unexpectedExportAssignment:
+        'Remove this runtime export assignment from the "types" file. "types.ts" may export types only.',
+      unexpectedValueExport:
+        'Move exported value "{{ name }}" out of this "types" file. "types.ts" may export types only; put runtime values in "constants.ts" or another implementation module instead.',
+      unexpectedValueExportAll:
+        'Do not re-export runtime values from "{{ exportPath }}" through a "types" file. Re-export them from "constants.ts" or another implementation module instead.',
+    },
+  },
+  create(context) {
+    if (!hasBaseName(context.filename, "types")) {
+      return {};
+    }
+
+    return {
+      ExportAllDeclaration(node) {
+        if (node.exportKind === "type") {
+          return;
+        }
+
+        context.report({
+          node,
+          messageId: "unexpectedValueExportAll",
+          data: {
+            exportPath: readLiteralStringValue(node.source) ?? "this module",
+          },
+        });
+      },
+      ExportDefaultDeclaration(node) {
+        context.report({
+          node,
+          messageId: "unexpectedDefaultExport",
+        });
+      },
+      ExportNamedDeclaration(node) {
+        if (node.declaration) {
+          if (isTypeDeclaration(node.declaration)) {
+            return;
+          }
+
+          const exportNames = readDeclarationIdentifierNames(node.declaration);
+          if (exportNames.length === 0) {
+            context.report({
+              node: node.declaration,
+              messageId: "unexpectedValueExport",
+              data: {
+                name: "this binding",
+              },
+            });
+            return;
+          }
+
+          exportNames.forEach((name) => {
+            context.report({
+              node: node.declaration,
+              messageId: "unexpectedValueExport",
+              data: {
+                name,
+              },
+            });
+          });
+          return;
+        }
+
+        node.specifiers.forEach((specifier) => {
+          if (isTypeOnlyExportSpecifier(specifier, node)) {
+            return;
+          }
+
+          context.report({
+            node: specifier,
+            messageId: "unexpectedValueExport",
+            data: {
+              name: readExportedSpecifierName(specifier),
+            },
+          });
+        });
+      },
+      TSExportAssignment(node) {
+        context.report({
+          node,
+          messageId: "unexpectedExportAssignment",
+        });
+      },
+    };
+  },
+};
+
+export default noValueExportsFromTypesRule;