agent-eslint-config 0.1.0 → 1.0.2

package/README.md

@@ -177,20 +177,16 @@ const registry: RegisteredUser[] = []
 
 async function processUserRegistration(input: unknown): Promise<RegisteredUser> {
   const data = input as any                           
-  if (!data.email || typeof data.email !== 'string') throw new Error('email is required')
-  if (!data.password || typeof data.password !== 'string') throw new Error('password is required')
-  const email = data.email.trim().toLowerCase()
-  if (!email.includes('@')) throw new Error('invalid email')
+  if (!data.email || typeof data.email !== 'string') throw new Error('email is required');
+  if (!data.password || typeof data.password !== 'string') throw new Error('password is required');
+  const email = data.email.trim().toLowerCase();
+  if (!email.includes('@')) throw new Error('invalid email');
   let hash = ''
   for (const character of data.password) {
-    if (typeof character === 'string') {
-      hash = hash + String(character.charCodeAt(0) * 31 % 255)
-    }
+    if (typeof character === 'string') { hash = hash + String(character.charCodeAt(0) * 31 % 255); }
   }
   for (const existing of registry) {
-    if (existing.email === email) {
-      throw new Error('email already registered')
-    }
+    if (existing.email === email) { throw new Error('email already registered'); }
   }
   const user = { id: String(registry.length + 1), email, passwordHash: hash }
   registry.push(user)
@@ -299,91 +295,136 @@ function notifyRegistration(user: RegisteredUser): void {
 Bad code:
 
 ```ts
-interface Account {
-  email: string | null
-  age: number
-  roles: string[]
+interface User {
+  role: string
+  isDeleted: boolean
+  emailVerified: boolean
 }
 
-function validateUser(account: Account | null): string {
-  if (account !== null) {
-    if (account.email !== null) {
-      if (account.email.includes('@')) {   // unicorn/no-lonely-if: lone `if` inside an `if`
-        if (account.age >= 18) {
-          if (account.roles.length > 0) {
-            return 'ok'
+declare const db: { users: { findById: (id: string) => Promise<User | null> } }
+
+async function validateUser(userId: string, role: string): Promise<User> {  // jsdoc/require-jsdoc + sonarjs/cognitive-complexity + max-statements
+  if (userId) {
+    const user = await db.users.findById(userId)
+    if (user) {
+      if (!user.isDeleted) {                 // max-depth + sonarjs/nested-control-flow: nested beyond 2 levels
+        if (user.role === role) {
+          if (user.emailVerified) {
+            // happy path buried 5 levels deep
+            return user
+          } else {
+            throw new Error('Email not verified')
           }
+        } else {
+          throw new Error('Insufficient role')
         }
+      } else {
+        throw new Error('User is deleted')
       }
+    } else {
+      throw new Error('User not found')
     }
+  } else {
+    throw new Error('User ID is required')
   }
-
-  return 'invalid'
 }
 ```
 
 Good code:
 
 ```ts
-interface Account {
-  email: string | null
-  age: number
-  roles: string[]
+interface User {
+  role: string
+  isDeleted: boolean
+  emailVerified: boolean
 }
 
 /**
- * Validates an account using flat guard clauses.
- * @param account The account to validate, or null.
- * @returns 'ok' when every requirement is met, otherwise 'invalid'.
+ * Loads a user and validates it with flat guard clauses.
+ * @param userId The id of the user to load.
+ * @param role The role the user must hold.
+ * @returns The validated, active user.
  */
-export function validateUser(account: Account | null): string {
-  if (account === null) {
-    return 'invalid'
+export async function validateUser(userId: string, role: string): Promise<User> {
+  if (!userId) {
+    throw new Error('User ID is required')
   }
 
-  if (!hasValidEmail(account.email)) {
-    return 'invalid'
-  }
-
-  if (account.age < 18) {
-    return 'invalid'
-  }
+  const user = await database.users.findById(userId)
 
-  if (account.roles.length === 0) {
-    return 'invalid'
-  }
+  assertActiveUser(user, role)
 
-  return 'ok'
+  return user
 }
 
 /**
- * Reports whether an email is present and well-formed.
- * @param email The email to check, or null.
- * @returns True when the email contains an '@'.
+ * Asserts the loaded user exists and is eligible for the role.
+ * @param user The loaded user, or null when none was found.
+ * @param role The role the user must hold.
  */
-function hasValidEmail(email: string | null): boolean {
-  return email !== null && email.includes('@')
+function assertActiveUser(user: User | null, role: string): asserts user is User {
+  if (!user) {
+    throw new Error('User not found')
+  }
+
+  if (user.isDeleted) {
+    throw new Error('User is deleted')
+  }
+
+  if (user.role !== role) {
+    throw new Error('Insufficient role')
+  }
+
+  if (!user.emailVerified) {
+    throw new Error('Email not verified')
+  }
 }
 ```
 
-### 3. Replace a static-only "helper" class
+### 3. Untangle a complex static-only "helper" class
 
 Bad code:
 
 ```ts
-class SubscriptionHelper {
-  static subscribers: string[] = []          // no-restricted-syntax: static property
+class PricingHelper {                        // unicorn/no-static-only-class + sonarjs/class-name (vague "Helper") + jsdoc/require-jsdoc
+  static VAT = 0.2                           // no-restricted-syntax: static property
+
+  static calc(t: string, qty: number, code: string, member: boolean): number {  // complexity + sonarjs/cognitive-complexity + no-restricted-syntax (static method) + id-length ('t')
+    let price = 0
+
+    if (t === 'book') {
+      price = 10
+    } else if (t === 'game') {
+      price = 40
+    } else if (t === 'film') {
+      price = 20
+    } else {
+      price = 5
+    }
 
-  static add(u: string): void {              // no-restricted-syntax: static method; id-length: `u`
-    SubscriptionHelper.subscribers.push(u)
-  }
+    let total = price * qty
 
-  static remove(u: string): void {
-    SubscriptionHelper.subscribers = SubscriptionHelper.subscribers.filter(x => x !== u)
-  }
+    if (qty > 100) {
+      total = total * 0.8
+    } else if (qty > 50) {
+      total = total * 0.9
+    } else if (qty > 10) {
+      total = total * 0.95
+    }
 
-  static count(): number {
-    return SubscriptionHelper.subscribers.length
+    if (member) {
+      if (code === 'GOLD') {
+        total = total * 0.85
+      } else if (code === 'SILVER') {
+        total = total * 0.9
+      }
+    }
+
+    if (total > 1000) {
+      total = total - 50
+    }
+
+    return total + total * PricingHelper.VAT
   }
 }
 ```
@@ -391,38 +432,94 @@ class SubscriptionHelper {
 Good code:
 
 ```ts
-/** Tracks newsletter subscribers in memory. */
-export class SubscriptionRegistry {
-  private readonly subscribers = new Set<string>()
+interface Order {
+  type: string
+  quantity: number
+  couponCode: string
+  isMember: boolean
+}
+
+/** Prices catalogue orders including quantity, membership discounts, and VAT. */
+export class PricingCalculator {
+  private readonly vatRate = 0.2
+
+  private readonly basePrices: Record<string, number> = { book: 10, game: 40, film: 20 }
+
+  private readonly memberCoupons: Record<string, number> = { GOLD: 0.85, SILVER: 0.9 }
+
+  private readonly bulkTiers = [
+    { min: 100, rate: 0.8 },
+    { min: 50, rate: 0.9 },
+    { min: 10, rate: 0.95 },
+  ]
+
+  /**
+   * Computes the final price of an order including discounts and VAT.
+   * @param order The order to price.
+   * @returns The final price with VAT applied.
+   */
+  price(order: Order): number {
+    const subtotal = this.subtotal(order)
+    const discounted = this.applyDiscounts(subtotal, order)
+
+    return this.withVat(discounted)
+  }
 
   /**
-   * Adds a subscriber by email.
-   * @param email The subscriber email.
-   * @returns The subscriber count after adding.
+   * Computes the pre-discount subtotal for an order.
+   * @param order The order to price.
+   * @returns The base price multiplied by quantity.
    */
-  add(email: string): number {
-    this.subscribers.add(email)
+  private subtotal(order: Order): number {
+    const base = this.basePrices[order.type] ?? 5
 
-    return this.subscribers.size
+    return base * order.quantity
   }
 
   /**
-   * Removes a subscriber by email.
-   * @param email The subscriber email.
-   * @returns The subscriber count after removing.
+   * Applies quantity and membership discounts to a subtotal.
+   * @param subtotal The pre-discount subtotal.
+   * @param order The order being priced.
+   * @returns The discounted amount.
    */
-  remove(email: string): number {
-    this.subscribers.delete(email)
+  private applyDiscounts(subtotal: number, order: Order): number {
+    const afterQuantity = subtotal * this.quantityRate(order.quantity)
+    const afterMember = afterQuantity * this.memberRate(order)
+
+    return afterMember > 1000 ? afterMember - 50 : afterMember
+  }
+
+  /**
+   * Resolves the quantity discount rate for an order size.
+   * @param quantity The number of items ordered.
+   * @returns A multiplier between 0 and 1.
+   */
+  private quantityRate(quantity: number): number {
+    const tier = this.bulkTiers.find(entry => quantity > entry.min)
+
+    return tier?.rate ?? 1
+  }
+
+  /**
+   * Resolves the membership coupon rate for an order.
+   * @param order The order being priced.
+   * @returns A multiplier between 0 and 1.
+   */
+  private memberRate(order: Order): number {
+    if (!order.isMember) {
+      return 1
+    }
 
-    return this.subscribers.size
+    return this.memberCoupons[order.couponCode] ?? 1
   }
 
   /**
-   * Counts the current subscribers.
-   * @returns The number of subscribers.
+   * Adds VAT to an amount.
+   * @param amount The pre-VAT amount.
+   * @returns The amount including VAT.
    */
-  count(): number {
-    return this.subscribers.size
+  private withVat(amount: number): number {
+    return amount + amount * this.vatRate
   }
 }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-eslint-config",
-  "version": "0.1.0",
+  "version": "1.0.2",
   "description": "Overly opionated eslint config for agents. Forces them to write low complexity and highly readable code. Supports: Claude, Gemini, Codex and many more.",
   "author": "Vlad Goncharov <vlad.goncharov@neolab.com>",
   "license": "MIT",
@@ -48,14 +48,21 @@
     "eslint": "^9.10.0 || ^10.0.0"
   },
   "devDependencies": {
+    "@semantic-release/git": "^10.0.1",
     "@types/node": "^25.6.2",
     "@typescript-eslint/rule-tester": "^8.62.0",
     "@typescript/native-preview": "7.0.0-dev.20260509.2",
     "bumpp": "^11.1.0",
     "concurrently": "^10.0.3",
+    "cz-conventional-changelog": "^3.3.0",
     "eslint": "^10.5.0",
     "tsdown": "^0.22.0",
     "typescript": "^6.0.3",
     "vitest": "^4.1.5"
+  },
+  "config": {
+    "commitizen": {
+      "path": "./node_modules/cz-conventional-changelog"
+    }
   }
 }