eslint-plugin-lookup-table

Finds repeated branching on the same discriminant and, when safe, autofixes it into a lookup table.

Why

Code that branches on the same discriminant more than once scatters related data across separate conditionals. Adding a new case means updating each branch. Miss one and the behavior drifts.

This rule targets a narrow failure mode in AI-assisted coding: incremental copy-paste edits that add another branch instead of collapsing repeated branching into a lookup table.

Before

const label =
  status === "loading" ? "Loading..."
  : status === "error" ? "Something went wrong"
  : status === "success" ? "Done"
  : "Unknown";

const icon =
  status === "loading" ? "⏳"
  : status === "error" ? "❌"
  : status === "success" ? "✅"
  : "❓";

const color =
  status === "loading" ? "blue"
  : status === "error" ? "red"
  : status === "success" ? "green"
  : "gray";

After (auto-fixed)

const _status_LOOKUP = {
  "loading": { label: "Loading...", icon: "⏳", color: "blue" },
  "error":   { label: "Something went wrong", icon: "❌", color: "red" },
  "success": { label: "Done", icon: "✅", color: "green" },
};
const _status_DEFAULT = { label: "Unknown", icon: "❓", color: "gray" };
const { label, icon, color } = _status_LOOKUP[status] ?? _status_DEFAULT;

One row per case. One place to edit.

Install

npm install --save-dev eslint-plugin-lookup-table

Requires ESLint 9+ (flat config).

Setup

// eslint.config.js
import lookupTable from "eslint-plugin-lookup-table";

export default [
  {
    plugins: { "lookup-table": lookupTable },
    rules: { "lookup-table/no-redundant-branching": "error" },
  },
];

Or use the recommended config:

import lookupTable from "eslint-plugin-lookup-table";
export default [lookupTable.configs.recommended];

What it detects

The rule finds 2+ conditional structures in the same scope that branch on the same variable with the same set of values.

Detected forms

| Form | Example | |------|---------| | Ternary chains | x === "a" ? 1 : x === "b" ? 2 : 3 | | If-else chains | if (x === "a") ... else if (x === "b") ... | | Switch statements | switch (x) { case "a": ... case "b": ... } | | Early-return blocks | if (x === "a") return {...}; if (x === "b") return {...}; | | Mixed forms | A ternary and a switch on the same discriminant |

Not detected

• Different discriminants (theme vs mode) — intentional
• Different branch sets (a,b vs a,c) — different structures
• Single chains below threshold — nothing to consolidate
• Chains in different scopes — cannot share a lookup table

Options

"lookup-table/no-redundant-branching": ["error", {
  threshold: 2,                  // chains needed to trigger (default: 2)
  includeSwitchStatements: true, // detect switch statements (default: true)
  includeIfElseChains: true,     // detect if-else and early-return (default: true)
  ignoreDiscriminants: ["theme"] // suppress specific discriminants
}]

Autofix safety

The autofix runs only when the transformation is safe:

| Condition | Behavior | |-----------|----------| | const declarations, contiguous, no side effects | Autofixes to lookup table | | Side effects in branches | Reports only | | Non-contiguous chains (code between them) | Reports only | | Non-const declarations | Reports only | | Early-return blocks | Reports only |

AI-assisted edits

This rule catches a narrow failure mode in AI-assisted coding: incremental copy-paste changes that add another branch instead of collapsing repeated branching into a lookup table. It does not address every kind of AI-generated bug.

The extension runs local ESLint logic. It does not call an external service, make a separate model request, or send code to another API. It adds a small local lint step, so expect a bit of CPU use and some extra latency after edits. In pi.dev, a short diagnostic can be fed back into the same session when the rule finds an issue.

AI harness integration

These configs run the rule after edits so you can catch redundant branching during the session, not just in CI.

pi.dev

Bundled — no separate package needed.

pi install npm:eslint-plugin-lookup-table

The extension runs local ESLint after write/edit events on TypeScript and JavaScript files. If it finds a violation, it can surface a short diagnostic back into the same session. It also registers a /lint-branching command for manual scans.

Claude Code

Copy .claude/ from harness-configs/claude-code/ into your project root. The PostToolUse hook runs local ESLint after writes and edits on .ts and .tsx files.

opencode

Copy .opencode/ from harness-configs/opencode/ into your project root. The plugin runs local ESLint after writes and edits on TypeScript files and logs diagnostics for the session.

Architecture

src/
├── index.ts                       # Plugin entry
├── pi-extension.ts                # pi.dev extension (auto-lint on write/edit)
├── rules/
│   └── no-redundant-branching.ts  # Rule: collect → group → report → fix
└── utils/
    ├── types.ts                   # ChainDescriptor, Branch, etc.
    ├── discriminant.ts            # Extract discriminant from === comparisons
    ├── chain-extractor.ts         # Parse ternary, if-else, switch, early-return
    ├── normalizer.ts              # Group chains by discriminant + structure
    └── autofix.ts                 # Generate lookup table replacement code

Contributing

git clone https://github.com/lnilluv/eslint-plugin-lookup-table.git
cd eslint-plugin-lookup-table
npm install
npm test        # 32 tests
npm run typecheck
npm run build

License

MIT