@alexgorbatchev/typescript-ai-policy 1.0.2 → 1.0.3

package/README.md

@@ -169,9 +169,10 @@ Repository-local development usage:
 
 - `bun run fix:semantic -- <target-directory>` — run the same semantic fixer from this repository checkout while developing the package itself.
 
-Today the framework applies two conservative semantic fixes:
+Today the framework applies three conservative semantic fixes:
 
 - `@alexgorbatchev/interface-naming-convention` — rename repository-owned interfaces to their required `I*` form when the existing name can be normalized safely.
+- `@alexgorbatchev/no-i-prefixed-type-aliases` — rename repository-owned type aliases to drop the interface-style `I*` prefix when the diagnostic resolves to a concrete type alias name safely.
 - `@alexgorbatchev/test-file-location-convention` — move misplaced `.test.ts` / `.test.tsx` files into a sibling `__tests__/` directory as `__tests__/basename.test.ts[x]` and rewrite the moved file's relative imports.
 
 The command and backend shape remain intentionally generic so more rule-backed semantic operations can be added later.
@@ -191,39 +192,40 @@ The command and backend shape remain intentionally generic so more rule-backed s
 
 For rule-by-rule rationale plus good/bad examples, see [`src/oxlint/README.md`](./src/oxlint/README.md).
 
-| Rule                                                            | Policy encoded                                                                                                                                                                                                                                                            |
-| --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `@alexgorbatchev/testid-naming-convention`                      | Non-story React test ids must be scoped to the owning component as `ComponentName` or `ComponentName--thing`.                                                                                                                                                             |
-| `@alexgorbatchev/no-react-create-element`                       | Regular application code must use JSX instead of `createElement`.                                                                                                                                                                                                         |
-| `@alexgorbatchev/require-component-root-testid`                 | Non-story exported React components must render a DOM root with `data-testid`/`testId` exactly equal to the component name, and child ids must use `ComponentName--thing`.                                                                                                |
-| `@alexgorbatchev/component-file-contract`                       | Component ownership files may export exactly one main runtime component plus unrestricted type-only API.                                                                                                                                                                  |
-| `@alexgorbatchev/component-file-naming-convention`              | Component filenames must match their exported PascalCase component name in either PascalCase or kebab-case form; non-component `.tsx` modules should be renamed to `.ts`.                                                                                                 |
-| `@alexgorbatchev/component-story-file-convention`               | Every component ownership file must have a matching `basename.stories.tsx` file somewhere under a sibling `stories/` directory.                                                                                                                                           |
-| `@alexgorbatchev/story-file-location-convention`                | Storybook files must live under sibling `stories/` directories and must still match a sibling component basename.                                                                                                                                                         |
-| `@alexgorbatchev/story-meta-type-annotation`                    | The default Storybook meta must use a typed `const meta: Meta<typeof ComponentName>` binding instead of object assertions.                                                                                                                                                |
-| `@alexgorbatchev/story-export-contract`                         | Story exports must use typed `Story` bindings, every story must define `play`, and single-story vs multi-story export shapes are enforced.                                                                                                                                |
-| `@alexgorbatchev/hook-file-contract`                            | Hook ownership files may export exactly one main runtime hook and it must use `export function useThing() {}` form.                                                                                                                                                       |
-| `@alexgorbatchev/hook-file-naming-convention`                   | Hook filenames must match their exported hook name as either `useFoo.ts[x]` or `use-foo.ts[x]`.                                                                                                                                                                           |
-| `@alexgorbatchev/hook-test-file-convention`                     | Every hook ownership file must have a matching `__tests__/basename.test.ts[x]` file somewhere under a sibling `__tests__/` directory, with the same source extension family.                                                                                              |
-| `@alexgorbatchev/no-non-running-tests`                          | Ban skip/todo/gated test modifiers that still leave non-running test code after the Jest rules run.                                                                                                                                                                       |
-| `@alexgorbatchev/no-conditional-logic-in-tests`                 | Ban `if`, `switch`, and ternary control flow in committed `*.test.ts(x)` files so assertions execute deterministically and test paths stay explicit.                                                                                                                      |
-| `@alexgorbatchev/no-throw-in-tests`                             | Ban `throw new Error(...)` in committed `*.test.ts(x)` files so failures use explicit `assert(...)` / `assert.fail(...)` calls instead of ad-hoc exception paths.                                                                                                         |
-| `@alexgorbatchev/no-module-mocking`                             | Ban whole-module mocking APIs and push tests toward dependency injection plus explicit stubs.                                                                                                                                                                             |
-| `@alexgorbatchev/no-test-file-exports`                          | Treat `*.test.ts(x)` files as execution units, not shared modules.                                                                                                                                                                                                        |
-| `@alexgorbatchev/no-imports-from-tests-directory`               | Files outside `__tests__/` must not import, require, or re-export modules from any `__tests__/` directory.                                                                                                                                                                |
-| `@alexgorbatchev/interface-naming-convention`                   | Repository-owned interfaces must use `I` followed by PascalCase; ambient external contract interfaces such as `Window` stay exempt.                                                                                                                                       |
-| `@alexgorbatchev/no-inline-type-expressions`                    | Explicit type usage must rely on named declarations or inference; do not define object, tuple, function, broad union, intersection, mapped, or conditional types inline at use sites. Narrow `T \| null \| undefined` wrappers stay allowed.                              |
-| `@alexgorbatchev/require-template-indent`                       | Multiline template literals that begin on their own line must keep their content indented with the surrounding code so embedded text stays reviewable and intentional.                                                                                                    |
-| `@alexgorbatchev/index-file-contract`                           | `index.ts` must stay a pure barrel: no local definitions, no side effects, only re-exports, and never `index.tsx`.                                                                                                                                                        |
-| `@alexgorbatchev/no-type-imports-from-constants`                | Types must not be imported from `constants` modules, including inline `import("./constants")` type queries.                                                                                                                                                               |
-| `@alexgorbatchev/no-type-exports-from-constants`                | `constants.ts` files may export runtime values only; exported types must move to `types.ts`.                                                                                                                                                                              |
-| `@alexgorbatchev/no-value-exports-from-types`                   | `types.ts` files may export type-only API only; runtime values and value re-exports must move elsewhere.                                                                                                                                                                  |
-| `@alexgorbatchev/test-file-location-convention`                 | Repository-owned `.test.ts` / `.test.tsx` files must live under `__tests__/` directories. `.spec.ts[x]` files are ignored by this rule. The semantic fixer moves misplaced `.test.ts[x]` files into a sibling `__tests__/` directory and rewrites their relative imports. |
-| `@alexgorbatchev/fixture-file-contract`                         | `__tests__/fixtures.ts(x)` and `stories/fixtures.ts(x)` may export only direct named `const` fixtures and named factory functions.                                                                                                                                        |
-| `@alexgorbatchev/fixture-export-naming-convention`              | Fixture entrypoint exports must use `fixture_<lowerCamelCase>` and `factory_<lowerCamelCase>`.                                                                                                                                                                            |
-| `@alexgorbatchev/fixture-export-type-contract`                  | Fixture entrypoint exports must declare explicit imported concrete types and must not use `any` or `unknown`.                                                                                                                                                             |
-| `@alexgorbatchev/no-fixture-exports-outside-fixture-entrypoint` | `fixture_*` and `factory_*` exports may exist only in nested `fixtures.ts(x)` entrypoints under `__tests__/` or `stories/`.                                                                                                                                               |
-| `@alexgorbatchev/no-inline-fixture-bindings-in-tests`           | Test and story files must import `fixture_*` and `factory_*` bindings from a relative `fixtures` module inside the same `__tests__/` or `stories/` tree instead of declaring them inline.                                                                                 |
-| `@alexgorbatchev/fixture-import-path-convention`                | Fixture-like imports inside test and story files must be named imports from a relative `fixtures` module inside the same `__tests__/` or `stories/` tree, with no aliasing.                                                                                               |
-| `@alexgorbatchev/no-local-type-declarations-in-fixture-files`   | Fixture files and `fixtures/` contents under `__tests__/` or `stories/` must import shared types instead of declaring local types, interfaces, or enums.                                                                                                                  |
-| `@alexgorbatchev/single-fixture-entrypoint`                     | Each fixture-support directory under `__tests__/` or `stories/` must choose exactly one fixture entrypoint shape: `fixtures.ts`, `fixtures.tsx`, or `fixtures/`.                                                                                                          |
+| Rule                                                            | Policy encoded                                                                                                                                                                                                                                                              |
+| --------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `@alexgorbatchev/testid-naming-convention`                      | Non-story React test ids must be scoped to the owning component as `ComponentName` or `ComponentName--thing`.                                                                                                                                                               |
+| `@alexgorbatchev/no-react-create-element`                       | Regular application code must use JSX instead of `createElement`.                                                                                                                                                                                                           |
+| `@alexgorbatchev/require-component-root-testid`                 | Non-story exported React components must render a DOM root with `data-testid`/`testId` exactly equal to the component name, and child ids must use `ComponentName--thing`.                                                                                                  |
+| `@alexgorbatchev/component-file-contract`                       | Component ownership files may export exactly one main runtime component plus unrestricted type-only API.                                                                                                                                                                    |
+| `@alexgorbatchev/component-file-naming-convention`              | Component filenames must match their exported PascalCase component name in either PascalCase or kebab-case form; non-component `.tsx` modules should be renamed to `.ts`.                                                                                                   |
+| `@alexgorbatchev/component-story-file-convention`               | Every component ownership file must have a matching `basename.stories.tsx` file somewhere under a sibling `stories/` directory.                                                                                                                                             |
+| `@alexgorbatchev/story-file-location-convention`                | Storybook files must live under sibling `stories/` directories and must still match a sibling component basename.                                                                                                                                                           |
+| `@alexgorbatchev/story-meta-type-annotation`                    | The default Storybook meta must use a typed `const meta: Meta<typeof ComponentName>` binding instead of object assertions.                                                                                                                                                  |
+| `@alexgorbatchev/story-export-contract`                         | Story exports must use typed `Story` bindings, every story must define `play`, and single-story vs multi-story export shapes are enforced.                                                                                                                                  |
+| `@alexgorbatchev/hook-file-contract`                            | Hook ownership files may export exactly one main runtime hook and it must use `export function useThing() {}` form.                                                                                                                                                         |
+| `@alexgorbatchev/hook-file-naming-convention`                   | Hook filenames must match their exported hook name as either `useFoo.ts[x]` or `use-foo.ts[x]`.                                                                                                                                                                             |
+| `@alexgorbatchev/hook-test-file-convention`                     | Every hook ownership file must have a matching `__tests__/basename.test.ts[x]` file somewhere under a sibling `__tests__/` directory, with the same source extension family.                                                                                                |
+| `@alexgorbatchev/no-non-running-tests`                          | Ban skip/todo/gated test modifiers that still leave non-running test code after the Jest rules run.                                                                                                                                                                         |
+| `@alexgorbatchev/no-conditional-logic-in-tests`                 | Ban `if`, `switch`, and ternary control flow in committed `*.test.ts(x)` files so assertions execute deterministically and test paths stay explicit.                                                                                                                        |
+| `@alexgorbatchev/no-throw-in-tests`                             | Ban `throw new Error(...)` in committed `*.test.ts(x)` files so failures use explicit `assert(...)` / `assert.fail(...)` calls instead of ad-hoc exception paths.                                                                                                           |
+| `@alexgorbatchev/no-module-mocking`                             | Ban whole-module mocking APIs and push tests toward dependency injection plus explicit stubs.                                                                                                                                                                               |
+| `@alexgorbatchev/no-test-file-exports`                          | Treat `*.test.ts(x)` files as execution units, not shared modules.                                                                                                                                                                                                          |
+| `@alexgorbatchev/no-imports-from-tests-directory`               | Files outside `__tests__/` must not import, require, or re-export modules from any `__tests__/` directory.                                                                                                                                                                  |
+| `@alexgorbatchev/interface-naming-convention`                   | Repository-owned interfaces must use `I` followed by PascalCase; ambient external contract interfaces such as `Window` stay exempt.                                                                                                                                         |
+| `@alexgorbatchev/no-i-prefixed-type-aliases`                    | Type aliases must not use the interface-style `I[A-Z]` prefix; this applies to `type` aliases only and does not change the separate interface naming contract.                                                                                                              |
+| `@alexgorbatchev/no-inline-type-expressions`                    | Explicit type usage must rely on named declarations or inference; do not define object, tuple, function, broad union, intersection, mapped, or conditional types inline at use sites. Narrow `T \| null \| undefined` wrappers stay allowed.                                |
+| `@alexgorbatchev/require-template-indent`                       | Multiline template literals that begin on their own line must keep their content indented with the surrounding code so embedded text stays reviewable and intentional; if indentation is significant, normalize the string explicitly with `@alexgorbatchev/dedent-string`. |
+| `@alexgorbatchev/index-file-contract`                           | `index.ts` must stay a pure barrel: no local definitions, no side effects, only re-exports, and never `index.tsx`.                                                                                                                                                          |
+| `@alexgorbatchev/no-type-imports-from-constants`                | Types must not be imported from `constants` modules, including inline `import("./constants")` type queries.                                                                                                                                                                 |
+| `@alexgorbatchev/no-type-exports-from-constants`                | `constants.ts` files may export runtime values only; exported types must move to `types.ts`.                                                                                                                                                                                |
+| `@alexgorbatchev/no-value-exports-from-types`                   | `types.ts` files may export type-only API only; runtime values and value re-exports must move elsewhere.                                                                                                                                                                    |
+| `@alexgorbatchev/test-file-location-convention`                 | Repository-owned `.test.ts` / `.test.tsx` files must live under `__tests__/` directories. `.spec.ts[x]` files are ignored by this rule. The semantic fixer moves misplaced `.test.ts[x]` files into a sibling `__tests__/` directory and rewrites their relative imports.   |
+| `@alexgorbatchev/fixture-file-contract`                         | `__tests__/fixtures.ts(x)` and `stories/fixtures.ts(x)` may export only direct named `const` fixtures and named factory functions.                                                                                                                                          |
+| `@alexgorbatchev/fixture-export-naming-convention`              | Fixture entrypoint exports must use `fixture_<lowerCamelCase>` and `factory_<lowerCamelCase>`.                                                                                                                                                                              |
+| `@alexgorbatchev/fixture-export-type-contract`                  | Fixture entrypoint exports must declare explicit imported concrete types and must not use `any` or `unknown`.                                                                                                                                                               |
+| `@alexgorbatchev/no-fixture-exports-outside-fixture-entrypoint` | `fixture_*` and `factory_*` exports may exist only in nested `fixtures.ts(x)` entrypoints under `__tests__/` or `stories/`.                                                                                                                                                 |
+| `@alexgorbatchev/no-inline-fixture-bindings-in-tests`           | Test and story files must import `fixture_*` and `factory_*` bindings from a relative `fixtures` module inside the same `__tests__/` or `stories/` tree instead of declaring them inline.                                                                                   |
+| `@alexgorbatchev/fixture-import-path-convention`                | Fixture-like imports inside test and story files must be named imports from a relative `fixtures` module inside the same `__tests__/` or `stories/` tree, with no aliasing.                                                                                                 |
+| `@alexgorbatchev/no-local-type-declarations-in-fixture-files`   | Fixture files and `fixtures/` contents under `__tests__/` or `stories/` must import shared types instead of declaring local types, interfaces, or enums.                                                                                                                    |
+| `@alexgorbatchev/single-fixture-entrypoint`                     | Each fixture-support directory under `__tests__/` or `stories/` must choose exactly one fixture entrypoint shape: `fixtures.ts`, `fixtures.tsx`, or `fixtures/`.                                                                                                            |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexgorbatchev/typescript-ai-policy",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Shared TypeScript AI policy configs and Oxlint rules",
   "homepage": "https://github.com/alexgorbatchev/typescript-ai-policy#readme",
   "repository": {

package/src/oxlint/createOxlintConfig.ts

@@ -47,6 +47,7 @@ const DEFAULT_OXLINT_CONFIG = defineConfig({
       files: ["**/*.{ts,tsx,mts,cts}"],
       rules: {
         "@alexgorbatchev/interface-naming-convention": "error",
+        "@alexgorbatchev/no-i-prefixed-type-aliases": "error",
         "@alexgorbatchev/no-inline-type-expressions": "error",
         "@alexgorbatchev/require-template-indent": "error",
       },

package/src/oxlint/plugin.ts

@@ -13,6 +13,7 @@ import noTypeImportsFromConstantsRule from "./rules/no-type-imports-from-constan
 import noTypeExportsFromConstantsRule from "./rules/no-type-exports-from-constants.ts";
 import noValueExportsFromTypesRule from "./rules/no-value-exports-from-types.ts";
 import interfaceNamingConventionRule from "./rules/interface-naming-convention.ts";
+import noIPrefixedTypeAliasesRule from "./rules/no-i-prefixed-type-aliases.ts";
 import noInlineTypeExpressionsRule from "./rules/no-inline-type-expressions.ts";
 import componentFileLocationConventionRule from "./rules/component-file-location-convention.ts";
 import componentDirectoryFileConventionRule from "./rules/component-directory-file-convention.ts";
@@ -59,6 +60,7 @@ const plugin = {
     "no-type-exports-from-constants": noTypeExportsFromConstantsRule,
     "no-value-exports-from-types": noValueExportsFromTypesRule,
     "interface-naming-convention": interfaceNamingConventionRule,
+    "no-i-prefixed-type-aliases": noIPrefixedTypeAliasesRule,
     "no-inline-type-expressions": noInlineTypeExpressionsRule,
     "component-file-location-convention": componentFileLocationConventionRule,
     "component-directory-file-convention": componentDirectoryFileConventionRule,

package/src/oxlint/rules/no-i-prefixed-type-aliases.ts

@@ -0,0 +1,45 @@
+import type { RuleModule } from "./types.ts";
+
+function readSuggestedTypeAliasName(typeAliasName: string): string {
+  return typeAliasName.slice(1);
+}
+
+function hasBlockedTypeAliasPrefix(typeAliasName: string): boolean {
+  return /^I[A-Z]/u.test(typeAliasName);
+}
+
+const noIPrefixedTypeAliasesRule: RuleModule = {
+  meta: {
+    type: "problem" as const,
+    docs: {
+      description:
+        'Disallow repository-owned type alias names that start with an "I" followed by another capital letter',
+    },
+    schema: [],
+    messages: {
+      unexpectedTypeAliasName:
+        'Rename type alias "{{ name }}" to remove the "I" prefix, for example "{{ suggestedName }}". Repository-owned type aliases must not use the interface-style "I[A-Z]" prefix.',
+    },
+  },
+  create(context) {
+    return {
+      TSTypeAliasDeclaration(node) {
+        const typeAliasName = node.id.name;
+        if (!hasBlockedTypeAliasPrefix(typeAliasName)) {
+          return;
+        }
+
+        context.report({
+          node: node.id,
+          messageId: "unexpectedTypeAliasName",
+          data: {
+            name: typeAliasName,
+            suggestedName: readSuggestedTypeAliasName(typeAliasName),
+          },
+        });
+      },
+    };
+  },
+};
+
+export default noIPrefixedTypeAliasesRule;

package/src/oxlint/rules/require-template-indent.ts

@@ -1,9 +1,13 @@
 import type { TSESTree } from "@typescript-eslint/types";
-import type { RuleModule } from "./types.ts";
+import type { RuleFixer, RuleModule } from "./types.ts";
 
-function readIndentSize(line: string): number {
+function readIndent(line: string): string {
   const indentMatch = line.match(/^[ \t]*/u);
-  return indentMatch ? indentMatch[0].length : 0;
+  return indentMatch ? indentMatch[0] : "";
+}
+
+function readIndentSize(line: string): number {
+  return readIndent(line).length;
 }
 
 function readMinimumContentIndent(content: string): number {
@@ -21,8 +25,8 @@ function readMinimumContentIndent(content: string): number {
   return Number.isFinite(minimumIndent) ? minimumIndent : 0;
 }
 
-function readTemplateContent(node: TSESTree.TemplateLiteral): string {
-  return node.quasis.map((quasi) => quasi.value.raw).join("${...}");
+function readTemplateContent(sourceText: string, node: TSESTree.TemplateLiteral): string {
+  return sourceText.slice(node.range[0] + 1, node.range[1] - 1);
 }
 
 function startsWithNewline(templateContent: string): boolean {
@@ -33,6 +37,32 @@ function hasNonEmptyContent(templateContent: string): boolean {
   return templateContent.replace(/^\n/u, "").trim().length > 0;
 }
 
+function readFixedTemplateContent(templateContent: string, indentPrefix: string): string {
+  const fixedContentLines = templateContent
+    .replace(/^\n/u, "")
+    .split("\n")
+    .map((contentLine) => {
+      if (contentLine.trim().length === 0) {
+        return contentLine;
+      }
+
+      return `${indentPrefix}${contentLine}`;
+    });
+
+  return `\n${fixedContentLines.join("\n")}`;
+}
+
+function readTemplateIndentFix(
+  fixer: RuleFixer,
+  node: TSESTree.TemplateLiteral,
+  templateContent: string,
+  indentPrefix: string,
+) {
+  const fixedTemplateContent = readFixedTemplateContent(templateContent, indentPrefix);
+
+  return fixer.replaceTextRange([node.range[0] + 1, node.range[1] - 1], fixedTemplateContent);
+}
+
 const requireTemplateIndentRule: RuleModule = {
   meta: {
     type: "problem" as const,
@@ -40,17 +70,19 @@ const requireTemplateIndentRule: RuleModule = {
       description: "Require multiline template literals to keep their content indented with the surrounding code",
     },
     schema: [],
+    fixable: "code" as const,
     messages: {
       badIndent:
-        "Indent this multiline template literal to match the surrounding code. If leading whitespace is part of the intended value, normalize the string explicitly instead of relying on under-indented source text.",
+        'Indent this multiline template literal to match the surrounding code. If indentation is significant, normalize the string explicitly with "@alexgorbatchev/dedent-string" instead of relying on under-indented source text.',
     },
   },
   create(context) {
-    const sourceLines = context.sourceCode.lines;
+    const sourceCode = context.getSourceCode?.() ?? context.sourceCode;
+    const sourceText = sourceCode.getText();
 
     return {
       TemplateLiteral(node) {
-        const templateContent = readTemplateContent(node);
+        const templateContent = readTemplateContent(sourceText, node);
         if (!startsWithNewline(templateContent) || !hasNonEmptyContent(templateContent)) {
           return;
         }
@@ -60,7 +92,7 @@ const requireTemplateIndentRule: RuleModule = {
           return;
         }
 
-        const sourceLine = sourceLines[startLine - 1];
+        const sourceLine = sourceCode.getLines()[startLine - 1];
         if (!sourceLine) {
           return;
         }
@@ -71,9 +103,14 @@ const requireTemplateIndentRule: RuleModule = {
           return;
         }
 
+        const indentPrefix = readIndent(sourceLine).slice(0, lineIndent - contentIndent);
+
         context.report({
           node,
           messageId: "badIndent",
+          fix(fixer) {
+            return readTemplateIndentFix(fixer, node, templateContent, indentPrefix);
+          },
         });
       },
     };

package/src/oxlint/rules/testid-naming-convention.ts

@@ -9,7 +9,7 @@ const testIdNamingConventionRule: RuleModule = {
     },
     messages: {
       invalidTestId:
-        'Rename {{ attributeName }} to "{{ componentName }}" on the component root, or to "{{ componentName }}--thing" on child elements. Received "{{ candidate }}".',
+        'Rename {{ attributeName }} "{{ candidate }}" to "{{ componentName }}" on the component root, or to "{{ componentName }}--thing" on child elements.',
     },
     schema: [],
     fixable: "code" as const,

package/src/semantic-fixes/applyFileChanges.ts

@@ -1,10 +1,10 @@
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { applyTextEdits, readUpdatedContent } from "./applyTextEdits.ts";
-import type { IFileMove, ITextEdit } from "./types.ts";
+import type { FileMove, TextEdit } from "./types.ts";
 
-function readTextEditsByFilePath(textEdits: readonly ITextEdit[]): Map<string, readonly ITextEdit[]> {
-  const textEditsByFilePath = new Map<string, ITextEdit[]>();
+function readTextEditsByFilePath(textEdits: readonly TextEdit[]): Map<string, readonly TextEdit[]> {
+  const textEditsByFilePath = new Map<string, TextEdit[]>();
 
   for (const textEdit of textEdits) {
     const existingTextEdits = textEditsByFilePath.get(textEdit.filePath);
@@ -19,7 +19,7 @@ function readTextEditsByFilePath(textEdits: readonly ITextEdit[]): Map<string, r
   return new Map(textEditsByFilePath);
 }
 
-function assertMoveFileOperationsAreSafe(fileMoves: readonly IFileMove[]): void {
+function assertMoveFileOperationsAreSafe(fileMoves: readonly FileMove[]): void {
   const sourceFilePathSet = new Set<string>();
   const destinationFilePathSet = new Set<string>();
 
@@ -41,7 +41,7 @@ function assertMoveFileOperationsAreSafe(fileMoves: readonly IFileMove[]): void
   }
 }
 
-function applyMovedFile(fileMove: IFileMove, textEdits: readonly ITextEdit[]): void {
+function applyMovedFile(fileMove: FileMove, textEdits: readonly TextEdit[]): void {
   if (!existsSync(fileMove.sourceFilePath)) {
     throw new Error(`Cannot move a missing file: ${fileMove.sourceFilePath}`);
   }
@@ -58,7 +58,7 @@ function applyMovedFile(fileMove: IFileMove, textEdits: readonly ITextEdit[]): v
   rmSync(fileMove.sourceFilePath);
 }
 
-export function applyFileChanges(textEdits: readonly ITextEdit[], fileMoves: readonly IFileMove[]): readonly string[] {
+export function applyFileChanges(textEdits: readonly TextEdit[], fileMoves: readonly FileMove[]): readonly string[] {
   assertMoveFileOperationsAreSafe(fileMoves);
 
   const changedFilePathSet = new Set<string>();

package/src/semantic-fixes/applySemanticFixes.ts

@@ -2,19 +2,20 @@ import { dirname, isAbsolute, relative, resolve } from "node:path";
 import { applyFileChanges } from "./applyFileChanges.ts";
 import { createTsgoLspSemanticFixBackend } from "./backends/tsgo-lsp/createTsgoLspSemanticFixBackend.ts";
 import { createInterfaceNamingConventionSemanticFixProvider } from "./providers/createInterfaceNamingConventionSemanticFixProvider.ts";
+import { createNoIPrefixedTypeAliasesSemanticFixProvider } from "./providers/createNoIPrefixedTypeAliasesSemanticFixProvider.ts";
 import { createTestFileLocationConventionSemanticFixProvider } from "./providers/createTestFileLocationConventionSemanticFixProvider.ts";
 import { runOxlintJson } from "./runOxlintJson.ts";
 import type {
-  IApplySemanticFixesOptions,
-  IApplySemanticFixesProgressEvent,
-  IApplySemanticFixesResult,
-  IOxlintDiagnostic,
-  ISemanticFixOperation,
-  ISemanticFixPlan,
-  ISkippedDiagnostic,
+  ApplySemanticFixesOptions,
+  ApplySemanticFixesProgressEvent,
+  ApplySemanticFixesResult,
+  OxlintDiagnostic,
+  SemanticFixOperation,
+  SemanticFixPlan,
+  SkippedDiagnostic,
 } from "./types.ts";
 
-function readAbsoluteDiagnosticFilePath(targetDirectoryPath: string, diagnostic: IOxlintDiagnostic): string {
+function readAbsoluteDiagnosticFilePath(targetDirectoryPath: string, diagnostic: OxlintDiagnostic): string {
   if (isAbsolute(diagnostic.filename)) {
     return diagnostic.filename;
   }
@@ -24,9 +25,9 @@ function readAbsoluteDiagnosticFilePath(targetDirectoryPath: string, diagnostic:
 
 function readSkippedDiagnostic(
   targetDirectoryPath: string,
-  diagnostic: IOxlintDiagnostic,
+  diagnostic: OxlintDiagnostic,
   reason: string,
-): ISkippedDiagnostic {
+): SkippedDiagnostic {
   return {
     filePath: readAbsoluteDiagnosticFilePath(targetDirectoryPath, diagnostic),
     reason,
@@ -34,14 +35,14 @@ function readSkippedDiagnostic(
   };
 }
 
-function readPlanSignature(plan: ISemanticFixPlan): string {
+function readPlanSignature(plan: SemanticFixPlan): string {
   return JSON.stringify({
     fileMoves: plan.fileMoves,
     textEdits: plan.textEdits,
   });
 }
 
-function readChangedFilePaths(plans: readonly ISemanticFixPlan[]): readonly string[] {
+function readChangedFilePaths(plans: readonly SemanticFixPlan[]): readonly string[] {
   const changedFilePathSet = new Set<string>();
   const movedFilePathMap = new Map<string, string>();
 
@@ -61,7 +62,7 @@ function readChangedFilePaths(plans: readonly ISemanticFixPlan[]): readonly stri
   return [...changedFilePathSet].sort((left, right) => left.localeCompare(right));
 }
 
-function readOperationDescription(operation: ISemanticFixOperation): string {
+function readOperationDescription(operation: SemanticFixOperation): string {
   switch (operation.kind) {
     case "rename-symbol": {
       return `Rename ${operation.symbolName} to ${operation.newName}`;
@@ -72,7 +73,7 @@ function readOperationDescription(operation: ISemanticFixOperation): string {
   }
 }
 
-function readOperationEmptyPlanReason(operation: ISemanticFixOperation): string {
+function readOperationEmptyPlanReason(operation: SemanticFixOperation): string {
   switch (operation.kind) {
     case "rename-symbol": {
       return `No text edits were produced for ${operation.symbolName}.`;
@@ -83,8 +84,8 @@ function readOperationEmptyPlanReason(operation: ISemanticFixOperation): string
   }
 }
 
-function readUniqueOperations(operations: readonly ISemanticFixOperation[]): readonly ISemanticFixOperation[] {
-  const operationMap = new Map<string, ISemanticFixOperation>();
+function readUniqueOperations(operations: readonly SemanticFixOperation[]): readonly SemanticFixOperation[] {
+  const operationMap = new Map<string, SemanticFixOperation>();
 
   for (const operation of operations) {
     operationMap.set(operation.id, operation);
@@ -93,8 +94,8 @@ function readUniqueOperations(operations: readonly ISemanticFixOperation[]): rea
   return [...operationMap.values()];
 }
 
-function readUniquePlans(plans: readonly ISemanticFixPlan[]): readonly ISemanticFixPlan[] {
-  const planMap = new Map<string, ISemanticFixPlan>();
+function readUniquePlans(plans: readonly SemanticFixPlan[]): readonly SemanticFixPlan[] {
+  const planMap = new Map<string, SemanticFixPlan>();
 
   for (const plan of plans) {
     planMap.set(readPlanSignature(plan), plan);
@@ -103,14 +104,16 @@ function readUniquePlans(plans: readonly ISemanticFixPlan[]): readonly ISemantic
   return [...planMap.values()];
 }
 
-export async function applySemanticFixes(options: IApplySemanticFixesOptions): Promise<IApplySemanticFixesResult> {
-  const reportProgress = (event: IApplySemanticFixesProgressEvent): void => {
+export async function applySemanticFixes(options: ApplySemanticFixesOptions): Promise<ApplySemanticFixesResult> {
+  const reportProgress = (event: ApplySemanticFixesProgressEvent): void => {
     options.onProgress?.(event);
   };
   const semanticFixProviders = new Map(
-    [createInterfaceNamingConventionSemanticFixProvider(), createTestFileLocationConventionSemanticFixProvider()].map(
-      (semanticFixProvider) => [semanticFixProvider.ruleCode, semanticFixProvider],
-    ),
+    [
+      createInterfaceNamingConventionSemanticFixProvider(),
+      createNoIPrefixedTypeAliasesSemanticFixProvider(),
+      createTestFileLocationConventionSemanticFixProvider(),
+    ].map((semanticFixProvider) => [semanticFixProvider.ruleCode, semanticFixProvider]),
   );
   const semanticFixBackend = createTsgoLspSemanticFixBackend({
     tsgoExecutablePath: options.tsgoExecutablePath,
@@ -133,8 +136,8 @@ export async function applySemanticFixes(options: IApplySemanticFixesOptions): P
       kind: "collected-diagnostics",
     });
 
-    const skippedDiagnostics: ISkippedDiagnostic[] = [];
-    const operations: ISemanticFixOperation[] = [];
+    const skippedDiagnostics: SkippedDiagnostic[] = [];
+    const operations: SemanticFixOperation[] = [];
 
     for (const diagnostic of diagnostics) {
       const semanticFixProviderForDiagnostic = semanticFixProviders.get(diagnostic.code);
@@ -160,7 +163,7 @@ export async function applySemanticFixes(options: IApplySemanticFixesOptions): P
     }
 
     const uniqueOperations = readUniqueOperations(operations);
-    const plans: ISemanticFixPlan[] = [];
+    const plans: SemanticFixPlan[] = [];
 
     reportProgress({
       kind: "planning-start",

package/src/semantic-fixes/applyTextEdits.ts

@@ -1,20 +1,20 @@
 import { readFileSync, writeFileSync } from "node:fs";
 import ts from "typescript";
-import type { ITextEdit } from "./types.ts";
+import type { TextEdit } from "./types.ts";
 
-type IOffsetTextEdit = {
+type OffsetTextEdit = {
   endOffset: number;
   newText: string;
   startOffset: number;
 };
 
-type IFileEditEntry = {
+type FileEditEntry = {
   filePath: string;
-  textEdits: readonly ITextEdit[];
+  textEdits: readonly TextEdit[];
 };
 
-function readFileEditEntries(textEdits: readonly ITextEdit[]): readonly IFileEditEntry[] {
-  const textEditsByFilePath = new Map<string, ITextEdit[]>();
+function readFileEditEntries(textEdits: readonly TextEdit[]): readonly FileEditEntry[] {
+  const textEditsByFilePath = new Map<string, TextEdit[]>();
 
   for (const textEdit of textEdits) {
     const existingTextEdits = textEditsByFilePath.get(textEdit.filePath);
@@ -32,7 +32,7 @@ function readFileEditEntries(textEdits: readonly ITextEdit[]): readonly IFileEdi
   }));
 }
 
-function compareOffsetTextEditsAscending(left: IOffsetTextEdit, right: IOffsetTextEdit): number {
+function compareOffsetTextEditsAscending(left: OffsetTextEdit, right: OffsetTextEdit): number {
   if (left.startOffset !== right.startOffset) {
     return left.startOffset - right.startOffset;
   }
@@ -44,7 +44,7 @@ function compareOffsetTextEditsAscending(left: IOffsetTextEdit, right: IOffsetTe
   return left.newText.localeCompare(right.newText);
 }
 
-function compareOffsetTextEditsDescending(left: IOffsetTextEdit, right: IOffsetTextEdit): number {
+function compareOffsetTextEditsDescending(left: OffsetTextEdit, right: OffsetTextEdit): number {
   return compareOffsetTextEditsAscending(right, left);
 }
 
@@ -53,7 +53,7 @@ function readOffset(positionContent: string, line: number, character: number): n
   return ts.getPositionOfLineAndCharacter(sourceFile, line, character);
 }
 
-function readOffsetTextEdit(content: string, textEdit: ITextEdit): IOffsetTextEdit {
+function readOffsetTextEdit(content: string, textEdit: TextEdit): OffsetTextEdit {
   return {
     endOffset: readOffset(content, textEdit.end.line, textEdit.end.character),
     newText: textEdit.newText,
@@ -61,31 +61,31 @@ function readOffsetTextEdit(content: string, textEdit: ITextEdit): IOffsetTextEd
   };
 }
 
-function haveSameRange(left: IOffsetTextEdit, right: IOffsetTextEdit): boolean {
+function haveSameRange(left: OffsetTextEdit, right: OffsetTextEdit): boolean {
   return left.startOffset === right.startOffset && left.endOffset === right.endOffset;
 }
 
-function isInsertion(edit: IOffsetTextEdit): boolean {
+function isInsertion(edit: OffsetTextEdit): boolean {
   return edit.startOffset === edit.endOffset;
 }
 
-function haveSameInsertionPoint(left: IOffsetTextEdit, right: IOffsetTextEdit): boolean {
+function haveSameInsertionPoint(left: OffsetTextEdit, right: OffsetTextEdit): boolean {
   return isInsertion(left) && isInsertion(right) && left.startOffset === right.startOffset;
 }
 
-function rangesOverlap(left: IOffsetTextEdit, right: IOffsetTextEdit): boolean {
+function rangesOverlap(left: OffsetTextEdit, right: OffsetTextEdit): boolean {
   return left.startOffset < right.endOffset && right.startOffset < left.endOffset;
 }
 
-function containsRange(container: IOffsetTextEdit, candidate: IOffsetTextEdit): boolean {
+function containsRange(container: OffsetTextEdit, candidate: OffsetTextEdit): boolean {
   return container.startOffset <= candidate.startOffset && container.endOffset >= candidate.endOffset;
 }
 
 function readNormalizedOffsetTextEdits(
   filePath: string,
-  offsetTextEdits: readonly IOffsetTextEdit[],
-): readonly IOffsetTextEdit[] {
-  const normalizedOffsetTextEdits: IOffsetTextEdit[] = [];
+  offsetTextEdits: readonly OffsetTextEdit[],
+): readonly OffsetTextEdit[] {
+  const normalizedOffsetTextEdits: OffsetTextEdit[] = [];
 
   for (const offsetTextEdit of [...offsetTextEdits].sort(compareOffsetTextEditsAscending)) {
     const previousOffsetTextEdit = normalizedOffsetTextEdits.at(-1);
@@ -123,7 +123,7 @@ function readNormalizedOffsetTextEdits(
   return normalizedOffsetTextEdits;
 }
 
-export function readUpdatedContent(filePath: string, content: string, textEdits: readonly ITextEdit[]): string {
+export function readUpdatedContent(filePath: string, content: string, textEdits: readonly TextEdit[]): string {
   const offsetTextEdits = [
     ...readNormalizedOffsetTextEdits(
       filePath,
@@ -143,7 +143,7 @@ export function readUpdatedContent(filePath: string, content: string, textEdits:
   return updatedContent;
 }
 
-function applyFileTextEdits(filePath: string, textEdits: readonly ITextEdit[]): void {
+function applyFileTextEdits(filePath: string, textEdits: readonly TextEdit[]): void {
   const content = readFileSync(filePath, "utf8");
   const updatedContent = readUpdatedContent(filePath, content, textEdits);
 
@@ -152,7 +152,7 @@ function applyFileTextEdits(filePath: string, textEdits: readonly ITextEdit[]):
   }
 }
 
-export function applyTextEdits(textEdits: readonly ITextEdit[]): readonly string[] {
+export function applyTextEdits(textEdits: readonly TextEdit[]): readonly string[] {
   const changedFilePaths: string[] = [];
 
   for (const fileEditEntry of readFileEditEntries(textEdits)) {