@openrewrite/recipes-code-quality 0.1.0-20260409-154017

package/dist/simplify-redundant-logical-expression.js

@@ -0,0 +1,63 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimplifyRedundantLogicalExpression = void 0;
+const rewrite_1 = require("@openrewrite/rewrite");
+const javascript_1 = require("@openrewrite/rewrite/javascript");
+class SimplifyRedundantLogicalExpression extends rewrite_1.Recipe {
+    constructor() {
+        super(...arguments);
+        this.name = "org.openrewrite.javascript.cleanup.SimplifyRedundantLogicalExpression";
+        this.displayName = "Simplify redundant logical expressions";
+        this.description = "Replace `x && x` with `x` and `x || x` with `x`. " +
+            "Identical operands in a logical expression are redundant " +
+            "and often indicate a copy-paste mistake.";
+        this.tags = ["RSPEC-S1764"];
+        this.estimatedEffortPerOccurrence = 2;
+    }
+    editor() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new class extends javascript_1.JavaScriptVisitor {
+                visitBinary(binary, ctx) {
+                    const _super = Object.create(null, {
+                        visitBinary: { get: () => super.visitBinary }
+                    });
+                    return __awaiter(this, void 0, void 0, function* () {
+                        binary = (yield _super.visitBinary.call(this, binary, ctx));
+                        const op = binary.operator.element;
+                        if (op !== "And" && op !== "Or") {
+                            return binary;
+                        }
+                        if (yield expressionsEqual(binary.left, binary.right)) {
+                            return Object.assign(Object.assign({}, binary.left), { prefix: binary.prefix });
+                        }
+                        return binary;
+                    });
+                }
+            };
+        });
+    }
+}
+exports.SimplifyRedundantLogicalExpression = SimplifyRedundantLogicalExpression;
+function printNode(node) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const p = (0, rewrite_1.printer)("org.openrewrite.javascript.tree.JS$CompilationUnit");
+        return yield p.print(node);
+    });
+}
+function expressionsEqual(a, b) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const aText = (yield printNode(a)).trim();
+        const bText = (yield printNode(b)).trim();
+        return aText === bText;
+    });
+}
+//# sourceMappingURL=simplify-redundant-logical-expression.js.map

package/dist/simplify-redundant-logical-expression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simplify-redundant-logical-expression.js","sourceRoot":"","sources":["../src/simplify-redundant-logical-expression.ts"],"names":[],"mappings":";;;;;;;;;;;;AAeA,kDAAoF;AACpF,gEAAkE;AAalE,MAAa,kCAAmC,SAAQ,gBAAM;IAA9D;;QACI,SAAI,GAAG,uEAAuE,CAAC;QAC/E,gBAAW,GAAG,wCAAwC,CAAC;QACvD,gBAAW,GAAG,mDAAmD;YAC7D,2DAA2D;YAC3D,0CAA0C,CAAC;QAC/C,SAAI,GAAG,CAAC,aAAa,CAAC,CAAC;QACvB,iCAA4B,GAAG,CAAC,CAAC;IAyBrC,CAAC;IAvBS,MAAM;;YACR,OAAO,IAAI,KAAM,SAAQ,8BAAmC;gBACzC,WAAW,CACtB,MAAgB,EAChB,GAAqB;;;;;wBAErB,MAAM,IAAG,MAAM,OAAM,WAAW,YAAC,MAAM,EAAE,GAAG,CAAa,CAAA,CAAC;wBAE1D,MAAM,EAAE,GAAG,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC;wBACnC,IAAI,EAAE,UAAsB,IAAI,EAAE,SAAqB,EAAE,CAAC;4BACtD,OAAO,MAAM,CAAC;wBAClB,CAAC;wBAED,IAAI,MAAM,gBAAgB,CAAC,MAAM,CAAC,IAAsB,EAAE,MAAM,CAAC,KAAuB,CAAC,EAAE,CAAC;4BAGxF,uCAAY,MAAM,CAAC,IAAY,KAAE,MAAM,EAAE,MAAM,CAAC,MAAM,IAAE;wBAC5D,CAAC;wBAED,OAAO,MAAM,CAAC;oBAClB,CAAC;iBAAA;aACJ,CAAC;QACN,CAAC;KAAA;CACJ;AAhCD,gFAgCC;AAED,SAAe,SAAS,CAAC,IAAO;;QAC5B,MAAM,CAAC,GAAG,IAAA,iBAAO,EAAC,oDAAoD,CAAC,CAAC;QACxE,OAAO,MAAM,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;CAAA;AAED,SAAe,gBAAgB,CAAC,CAAiB,EAAE,CAAiB;;QAGhE,MAAM,KAAK,GAAG,CAAC,MAAM,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QAC1C,MAAM,KAAK,GAAG,CAAC,MAAM,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QAC1C,OAAO,KAAK,KAAK,KAAK,CAAC;IAC3B,CAAC;CAAA"}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@openrewrite/recipes-code-quality",
+  "version": "0.1.0-20260409-154017",
+  "license": "Moderne Source Available License",
+  "description": "OpenRewrite recipes for JavaScript/TypeScript code quality.",
+  "homepage": "https://github.com/moderneinc/recipes-javascript",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**",
+    "src/**"
+  ],
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf ./dist tsconfig.build.tsbuildinfo && tsc --build tsconfig.build.json",
+    "dev": "tsc --watch -p tsconfig.json",
+    "test": "npm run build && jest",
+    "ci:test": "jest"
+  },
+  "dependencies": {
+    "@openrewrite/rewrite": "next",
+    "immer": "^10.1.1"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.13",
+    "@types/node": "^22.5.4",
+    "jest": "^29.7.0",
+    "jest-junit": "^16.0.0",
+    "tmp-promise": "^3.0.3",
+    "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.6.2"
+  }
+}

package/src/all-branches-identical.ts

@@ -0,0 +1,133 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import {ExecutionContext, printer, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor} from "@openrewrite/rewrite/javascript";
+import {J, Statement} from "@openrewrite/rewrite/java";
+
+/**
+ * Replaces if/else-if/else chains where every branch has the same body
+ * with just the body.
+ *
+ * When all branches of a conditional execute identical code the condition
+ * is meaningless. The entire chain can be replaced with a single copy of
+ * the body, removing unnecessary complexity.
+ *
+ * Only applies when there is an explicit `else` so that all paths are
+ * covered.
+ */
+export class AllBranchesIdentical extends Recipe {
+    name = "org.openrewrite.javascript.cleanup.AllBranchesIdentical";
+    displayName = "Remove conditional with identical branches";
+    description = "Replace `if`/`else if`/`else` chains where every branch has " +
+        "the same body with just the body, since the condition has " +
+        "no effect on what code executes.";
+    tags = ["RSPEC-S3923"];
+    estimatedEffortPerOccurrence = 5;
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitIf(
+                ifStmt: J.If,
+                ctx: ExecutionContext
+            ): Promise<J | undefined> {
+                ifStmt = await super.visitIf(ifStmt, ctx) as J.If;
+
+                // Only process top-level if (not else-if branches).
+                // Start from parent cursor to avoid matching self.
+                const parentCursor = this.cursor.parent;
+                if (parentCursor) {
+                    const parentIf = parentCursor.firstEnclosing(
+                        (n): n is J.If => n.kind === J.Kind.If
+                    );
+                    if (parentIf) {
+                        return ifStmt;
+                    }
+                }
+
+                // Must have an explicit else to cover all cases
+                if (!hasExplicitElse(ifStmt)) {
+                    return ifStmt;
+                }
+
+                const bodies = collectBodies(ifStmt);
+                if (!await allBodiesEqual(bodies)) {
+                    return ifStmt;
+                }
+
+                // Replace with just the body, preserving the if prefix
+                const thenBody = ifStmt.thenPart.element;
+                return {...thenBody, prefix: ifStmt.prefix} as Statement & J;
+            }
+        };
+    }
+}
+
+function hasExplicitElse(ifStmt: J.If): boolean {
+    let current: J.If = ifStmt;
+    while (true) {
+        const elsePart = current.elsePart;
+        if (!elsePart) {
+            return false;
+        }
+        const body = elsePart.body.element;
+        if (body.kind === J.Kind.If) {
+            current = body as J.If;
+        } else {
+            // Reached a plain else block
+            return true;
+        }
+    }
+}
+
+function collectBodies(ifStmt: J.If): (Statement & J)[] {
+    const bodies: (Statement & J)[] = [ifStmt.thenPart.element as Statement & J];
+    let current: J.If = ifStmt;
+    while (true) {
+        const elsePart = current.elsePart;
+        if (!elsePart) {
+            break;
+        }
+        const body = elsePart.body.element;
+        if (body.kind === J.Kind.If) {
+            const elseIf = body as J.If;
+            bodies.push(elseIf.thenPart.element as Statement & J);
+            current = elseIf;
+        } else {
+            // Plain else body
+            bodies.push(body as Statement & J);
+            break;
+        }
+    }
+    return bodies;
+}
+
+async function printNode(node: J): Promise<string> {
+    const p = printer("org.openrewrite.javascript.tree.JS$CompilationUnit");
+    return (await p.print(node)).trim();
+}
+
+async function allBodiesEqual(bodies: (Statement & J)[]): Promise<boolean> {
+    if (bodies.length < 2) {
+        return false;
+    }
+    const firstText = await printNode(bodies[0]);
+    for (let i = 1; i < bodies.length; i++) {
+        if (await printNode(bodies[i]) !== firstText) {
+            return false;
+        }
+    }
+    return true;
+}

package/src/boolean-checks-not-inverted.ts

@@ -0,0 +1,144 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {capture, JavaScriptVisitor, pattern, rewrite, template} from "@openrewrite/rewrite/javascript";
+import {J} from "@openrewrite/rewrite/java";
+
+/**
+ * Replaces inverted boolean checks with their simpler equivalents.
+ *
+ * Negating a comparison with `!` when an opposite operator exists
+ * adds unnecessary mental overhead. Flipping the operator directly
+ * is shorter and reads more naturally.
+ *
+ * Also removes double negation (`!!x` is left alone as it is a common
+ * boolean-coercion idiom, but `!(!x)` with parentheses is simplified).
+ */
+export class BooleanChecksNotInverted extends Recipe {
+    name = "org.openrewrite.javascript.cleanup.BooleanChecksNotInverted";
+    displayName = "Boolean checks should not be inverted";
+    description = "Replaces inverted boolean comparisons with their simpler equivalents. " +
+        "For example, `!(a === b)` becomes `a !== b` and `!(a < b)` becomes `a >= b`. " +
+        "Also simplifies double negation like `!(!x)` to `x`.";
+    tags = ["RSPEC-S1940"];
+    estimatedEffortPerOccurrence = 2;
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        const a = () => capture();
+        const b = () => capture();
+
+        // !(a === b) -> a !== b
+        const notStrictEquals = rewrite(() => {
+            const [x, y] = [a(), b()];
+            return {
+                before: pattern`!(${x} === ${y})`,
+                after: template`${x} !== ${y}`
+            };
+        });
+
+        // !(a !== b) -> a === b
+        const notStrictNotEquals = rewrite(() => {
+            const [x, y] = [a(), b()];
+            return {
+                before: pattern`!(${x} !== ${y})`,
+                after: template`${x} === ${y}`
+            };
+        });
+
+        // !(a == b) -> a != b
+        const notLooseEquals = rewrite(() => {
+            const [x, y] = [a(), b()];
+            return {
+                before: pattern`!(${x} == ${y})`,
+                after: template`${x} != ${y}`
+            };
+        });
+
+        // !(a != b) -> a == b
+        const notLooseNotEquals = rewrite(() => {
+            const [x, y] = [a(), b()];
+            return {
+                before: pattern`!(${x} != ${y})`,
+                after: template`${x} == ${y}`
+            };
+        });
+
+        // !(a < b) -> a >= b
+        const notLessThan = rewrite(() => {
+            const [x, y] = [a(), b()];
+            return {
+                before: pattern`!(${x} < ${y})`,
+                after: template`${x} >= ${y}`
+            };
+        });
+
+        // !(a > b) -> a <= b
+        const notGreaterThan = rewrite(() => {
+            const [x, y] = [a(), b()];
+            return {
+                before: pattern`!(${x} > ${y})`,
+                after: template`${x} <= ${y}`
+            };
+        });
+
+        // !(a <= b) -> a > b
+        const notLessOrEqual = rewrite(() => {
+            const [x, y] = [a(), b()];
+            return {
+                before: pattern`!(${x} <= ${y})`,
+                after: template`${x} > ${y}`
+            };
+        });
+
+        // !(a >= b) -> a < b
+        const notGreaterOrEqual = rewrite(() => {
+            const [x, y] = [a(), b()];
+            return {
+                before: pattern`!(${x} >= ${y})`,
+                after: template`${x} < ${y}`
+            };
+        });
+
+        // !(!x) -> x (double negation with parentheses)
+        const doubleNegation = rewrite(() => {
+            const x = capture();
+            return {
+                before: pattern`!(!${x})`,
+                after: template`${x}`
+            };
+        });
+
+        const rules = notStrictEquals
+            .orElse(notStrictNotEquals)
+            .orElse(notLooseEquals)
+            .orElse(notLooseNotEquals)
+            .orElse(notLessThan)
+            .orElse(notGreaterThan)
+            .orElse(notLessOrEqual)
+            .orElse(notGreaterOrEqual)
+            .orElse(doubleNegation);
+
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitUnary(
+                unary: J.Unary,
+                ctx: ExecutionContext
+            ): Promise<J | undefined> {
+                unary = await super.visitUnary(unary, ctx) as J.Unary;
+                return await rules.tryOn(this.cursor, unary) || unary;
+            }
+        };
+    }
+}

package/src/collapsible-if-statements.ts

@@ -0,0 +1,162 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS, template} from "@openrewrite/rewrite/javascript";
+import {emptySpace, Expression, J} from "@openrewrite/rewrite/java";
+
+/**
+ * Merges collapsible if statements into a single condition joined by `&&`.
+ *
+ * When an `if` block contains nothing but another `if` and neither has
+ * an `else` branch, the two conditions can be combined. This reduces
+ * nesting depth and makes the guard logic easier to follow at a glance.
+ *
+ * If the inner condition is a logical-or expression it is wrapped in
+ * parentheses to preserve evaluation order.
+ */
+export class CollapsibleIfStatements extends Recipe {
+    name = "org.openrewrite.javascript.cleanup.CollapsibleIfStatements";
+    displayName = "Collapsible if statements should be merged";
+    description = "Merges nested if statements that can be combined with `&&`. " +
+        "For example, `if (a) { if (b) { ... } }` becomes `if (a && b) { ... }`. " +
+        "Only applies when neither if has an else clause and the outer body contains " +
+        "only the inner if.";
+    tags = ["RSPEC-S1066"];
+    estimatedEffortPerOccurrence = 5;
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitIf(
+                ifStmt: J.If,
+                ctx: ExecutionContext
+            ): Promise<J | undefined> {
+                ifStmt = await super.visitIf(ifStmt, ctx) as J.If;
+
+                // Must not have an else branch
+                if (ifStmt.elsePart) {
+                    return ifStmt;
+                }
+
+                // The body must be a block containing exactly one statement
+                const body = ifStmt.thenPart.element;
+                if (body.kind !== J.Kind.Block) {
+                    return ifStmt;
+                }
+
+                const block = body as J.Block;
+                if (block.statements.length !== 1) {
+                    return ifStmt;
+                }
+
+                // That single statement must be another if with no else
+                const inner = block.statements[0].element;
+                if (inner.kind !== J.Kind.If) {
+                    return ifStmt;
+                }
+
+                const innerIf = inner as J.If;
+                if (innerIf.elsePart) {
+                    return ifStmt;
+                }
+
+                // Build the combined condition: outerCond && innerCond
+                // Strip any existing prefix (whitespace/newlines) from the
+                // conditions so the template controls spacing
+                const outerCond = {...(ifStmt.ifCondition.tree.element as Expression & J), prefix: emptySpace} as Expression;
+                const innerCond = {...(innerIf.ifCondition.tree.element as Expression & J), prefix: emptySpace} as Expression;
+
+                // If inner condition is || expression, wrap in parens
+                const needsParens = innerCond.kind === J.Kind.Binary &&
+                    (innerCond as J.Binary).operator.element === J.Binary.Type.Or;
+
+                let combined: J | undefined;
+                if (needsParens) {
+                    combined = await template`${outerCond} && (${innerCond})`.apply(
+                        ifStmt.ifCondition.tree.element, this.cursor
+                    );
+                } else {
+                    combined = await template`${outerCond} && ${innerCond}`.apply(
+                        ifStmt.ifCondition.tree.element, this.cursor
+                    );
+                }
+
+                if (!combined) {
+                    return ifStmt;
+                }
+
+                // The template may wrap the result in an ExpressionStatement;
+                // unwrap it to get the actual expression.
+                if (combined.kind === JS.Kind.ExpressionStatement) {
+                    combined = (combined as JS.ExpressionStatement).expression as J;
+                }
+
+                // Strip any leading newline from the combined expression.
+                combined = stripLeadingNewline(combined);
+
+                // Fix the inner then-body indentation: it was nested one level
+                // deeper, so we need to dedent by one level
+                const innerBody = innerIf.thenPart.element as J;
+                const outerIndent = getIndent(ifStmt.prefix);
+                const dedented = dedentBlock(innerBody as J.Block, outerIndent);
+
+                return await this.produceJava(ifStmt, ctx, draft => {
+                    (draft.ifCondition.tree as any).element = combined;
+                    (draft.thenPart as any).element = dedented;
+                });
+            }
+        };
+    }
+}
+
+function stripLeadingNewline(node: J): J {
+    // The prefix of the outermost node may not have the newline;
+    // it might be on the leftmost child. Walk down the left spine.
+    if (node.prefix.whitespace.includes('\n')) {
+        return {...node, prefix: emptySpace};
+    }
+    // For binary expressions, the newline might be on the left operand
+    if (node.kind === J.Kind.Binary) {
+        const bin = node as J.Binary;
+        const newLeft = stripLeadingNewline(bin.left as J);
+        if (newLeft !== bin.left) {
+            return {...bin, left: newLeft as Expression} as unknown as J;
+        }
+    }
+    return node;
+}
+
+function getIndent(sp: J.Space): string {
+    const ws = sp.whitespace;
+    const lastNewline = ws.lastIndexOf('\n');
+    if (lastNewline === -1) {
+        return "";
+    }
+    return ws.substring(lastNewline + 1);
+}
+
+function dedentBlock(block: J.Block, outerIndent: string): J.Block {
+    const bodyIndent = outerIndent + "    ";
+
+    const newStmts = block.statements.map(stmt => {
+        const el = stmt.element as J;
+        const newPrefix = {...el.prefix, whitespace: "\n" + bodyIndent};
+        return {...stmt, element: {...el, prefix: newPrefix}};
+    });
+
+    const newEnd = {...block.end, whitespace: "\n" + outerIndent};
+
+    return {...block, statements: newStmts, end: newEnd} as J.Block;
+}

package/src/index.ts

@@ -0,0 +1,34 @@
+import {CategoryDescriptor, RecipeMarketplace} from "@openrewrite/rewrite";
+import {AllBranchesIdentical} from "./all-branches-identical";
+import {SimplifyBooleanLiteral} from "./simplify-boolean-literal";
+import {BooleanChecksNotInverted} from "./boolean-checks-not-inverted";
+import {CollapsibleIfStatements} from "./collapsible-if-statements";
+import {MergeIdenticalBranches} from "./merge-identical-branches";
+import {RemoveDuplicateConditions} from "./remove-duplicate-conditions";
+import {RemoveSelfAssignment} from "./remove-self-assignment";
+import {RemoveUnconditionalValueOverwrite} from "./remove-unconditional-value-overwrite";
+import {SimplifyRedundantLogicalExpression} from "./simplify-redundant-logical-expression";
+
+export const CodeQuality: CategoryDescriptor[] = [{displayName: "Code quality"}];
+
+export async function activate(marketplace: RecipeMarketplace): Promise<void> {
+    await marketplace.install(AllBranchesIdentical, CodeQuality);
+    await marketplace.install(SimplifyBooleanLiteral, CodeQuality);
+    await marketplace.install(BooleanChecksNotInverted, CodeQuality);
+    await marketplace.install(CollapsibleIfStatements, CodeQuality);
+    await marketplace.install(MergeIdenticalBranches, CodeQuality);
+    await marketplace.install(RemoveDuplicateConditions, CodeQuality);
+    await marketplace.install(RemoveSelfAssignment, CodeQuality);
+    await marketplace.install(RemoveUnconditionalValueOverwrite, CodeQuality);
+    await marketplace.install(SimplifyRedundantLogicalExpression, CodeQuality);
+}
+
+export {AllBranchesIdentical} from "./all-branches-identical";
+export {SimplifyBooleanLiteral} from "./simplify-boolean-literal";
+export {BooleanChecksNotInverted} from "./boolean-checks-not-inverted";
+export {CollapsibleIfStatements} from "./collapsible-if-statements";
+export {MergeIdenticalBranches} from "./merge-identical-branches";
+export {RemoveDuplicateConditions} from "./remove-duplicate-conditions";
+export {RemoveSelfAssignment} from "./remove-self-assignment";
+export {RemoveUnconditionalValueOverwrite} from "./remove-unconditional-value-overwrite";
+export {SimplifyRedundantLogicalExpression} from "./simplify-redundant-logical-expression";