ima-claude 2.9.0

package/plugins/ima-claude/skills/js-fp/examples/pure-functions.js

@@ -0,0 +1,260 @@
+/**
+ * Pure Functions Examples
+ *
+ * Demonstrating core FP concepts with practical examples
+ */
+
+// ============================================================================
+// 1. BASIC PURITY
+// ============================================================================
+
+// ❌ Impure: Depends on external state
+let taxRate = 0.1
+const calculateTotalImpure = (price) => price * (1 + taxRate)
+
+// ✅ Pure: All dependencies explicit
+const calculateTotal = (price, taxRate) => price * (1 + taxRate)
+
+// ✅ Pure with pre-configuration
+const createTaxCalculator = (taxRate) => (price) => price * (1 + taxRate)
+const calculateWithTax = createTaxCalculator(0.1)
+
+// ============================================================================
+// 2. COMPOSITION WITHOUT UTILITIES
+// ============================================================================
+
+// Data validation example
+const validateRequired = (value) => value != null && value !== ''
+const validateEmail = (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)
+const validateLength = (min, max) => (value) =>
+  value.length >= min && value.length <= max
+
+// Compose with early returns (no pipe utility needed)
+const validateUserEmail = (email) => {
+  if (!validateRequired(email)) {
+    return { valid: false, error: 'Email is required' }
+  }
+
+  if (!validateEmail(email)) {
+    return { valid: false, error: 'Invalid email format' }
+  }
+
+  if (!validateLength(5, 100)(email)) {
+    return { valid: false, error: 'Email must be 5-100 characters' }
+  }
+
+  return { valid: true, value: email }
+}
+
+// ============================================================================
+// 3. DEPENDENCY INJECTION
+// ============================================================================
+
+// Pure business logic
+const hashPassword = (password, hasher) => hasher.hash(password)
+const saveToDatabase = (data, database) => database.save(data)
+
+// Compose with explicit dependencies
+const saveUser = async (userData, hasher, database) => {
+  const hashedPassword = await hashPassword(userData.password, hasher)
+  const userToSave = { ...userData, password: hashedPassword }
+  return saveToDatabase(userToSave, database)
+}
+
+// Function factory for convenience
+const createUserService = (hasher, database) => ({
+  save: (userData) => saveUser(userData, hasher, database),
+  find: (id) => database.findById(id)
+})
+
+// ============================================================================
+// 4. IMMUTABILITY
+// ============================================================================
+
+// Pure array operations
+const users = [
+  { id: 1, name: 'Alice', active: true },
+  { id: 2, name: 'Bob', active: false },
+  { id: 3, name: 'Charlie', active: true }
+]
+
+// Add user (immutable)
+const addUser = (users, newUser) => [...users, newUser]
+
+// Remove user (immutable)
+const removeUser = (users, userId) =>
+  users.filter(user => user.id !== userId)
+
+// Update user (immutable)
+const updateUser = (users, userId, updates) =>
+  users.map(user =>
+    user.id === userId ? { ...user, ...updates } : user
+  )
+
+// Filter active users
+const getActiveUsers = (users) => users.filter(user => user.active)
+
+// ============================================================================
+// 5. DATA TRANSFORMATION PIPELINE
+// ============================================================================
+
+// Transform user data without utilities
+const processUserData = (rawData) => {
+  // Normalize
+  const normalized = {
+    id: rawData.id,
+    name: rawData.name?.trim() || '',
+    email: rawData.email?.toLowerCase() || ''
+  }
+
+  // Validate
+  const emailValidation = validateUserEmail(normalized.email)
+  if (!emailValidation.valid) {
+    return { valid: false, error: emailValidation.error }
+  }
+
+  // Enhance
+  const enhanced = {
+    ...normalized,
+    displayName: normalized.name || 'Anonymous',
+    createdAt: new Date().toISOString()
+  }
+
+  return { valid: true, data: enhanced }
+}
+
+// ============================================================================
+// 6. ERROR HANDLING
+// ============================================================================
+
+// Result type pattern
+const divide = (a, b) =>
+  b === 0
+    ? { success: false, error: 'Division by zero' }
+    : { success: true, data: a / b }
+
+// Chain operations with early returns
+const calculate = (a, b, c) => {
+  const step1 = divide(a, b)
+  if (!step1.success) return step1
+
+  const step2 = divide(step1.data, c)
+  return step2
+}
+
+// Try-catch wrapper for async
+const tryCatch = (fn) => async (...args) => {
+  try {
+    const data = await fn(...args)
+    return { success: true, data }
+  } catch (error) {
+    return { success: false, error: error.message }
+  }
+}
+
+// ============================================================================
+// 7. CONFIGURATION PRE-COMPILATION (Performance)
+// ============================================================================
+
+// Problem: O(items × validators) - repeated config access
+const validateItemsSlow = (items, validators) => {
+  return items.map(item => {
+    const errors = []
+    for (const validator of validators) {
+      if (!validator.validate(item[validator.field])) {
+        errors.push(validator.message)
+      }
+    }
+    return { item, valid: errors.length === 0, errors }
+  })
+}
+
+// Solution: O(validators + items) - pre-compiled
+const createItemValidator = (validators) => {
+  // Pre-compile validator functions
+  const compiledValidators = validators.map(v => ({
+    field: v.field,
+    validate: v.validate,
+    message: v.message
+  }))
+
+  return (item) => {
+    const errors = []
+    for (const validator of compiledValidators) {
+      if (!validator.validate(item[validator.field])) {
+        errors.push(validator.message)
+      }
+    }
+    return { item, valid: errors.length === 0, errors }
+  }
+}
+
+const validateItemsFast = (items, validators) => {
+  const validator = createItemValidator(validators)
+  return items.map(validator)
+}
+
+// ============================================================================
+// 8. MEMOIZATION (Pure Functions Only)
+// ============================================================================
+
+const memoize = (fn) => {
+  const cache = new Map()
+  return (...args) => {
+    const key = JSON.stringify(args)
+    if (cache.has(key)) return cache.get(key)
+    const result = fn(...args)
+    cache.set(key, result)
+    return result
+  }
+}
+
+// Expensive calculation (pure)
+const fibonacci = (n) => {
+  if (n <= 1) return n
+  return fibonacci(n - 1) + fibonacci(n - 2)
+}
+
+const fibonacciMemoized = memoize(fibonacci)
+
+// ============================================================================
+// EXPORTS FOR TESTING
+// ============================================================================
+
+module.exports = {
+  // Basic purity
+  calculateTotal,
+  createTaxCalculator,
+
+  // Composition
+  validateRequired,
+  validateEmail,
+  validateLength,
+  validateUserEmail,
+
+  // Dependency injection
+  saveUser,
+  createUserService,
+
+  // Immutability
+  addUser,
+  removeUser,
+  updateUser,
+  getActiveUsers,
+
+  // Data transformation
+  processUserData,
+
+  // Error handling
+  divide,
+  calculate,
+  tryCatch,
+
+  // Performance
+  createItemValidator,
+  validateItemsFast,
+
+  // Memoization
+  memoize,
+  fibonacciMemoized
+}

package/plugins/ima-claude/skills/js-fp/examples/tests/pure-functions.test.js

@@ -0,0 +1,262 @@
+/**
+ * Pure Functions Test Suite
+ *
+ * Demonstrating comprehensive testing enabled by purity
+ */
+
+const {
+  calculateTotal,
+  createTaxCalculator,
+  validateRequired,
+  validateEmail,
+  validateUserEmail,
+  addUser,
+  removeUser,
+  updateUser,
+  divide,
+  calculate,
+  memoize
+} = require('../pure-functions')
+
+describe('Pure Functions - Comprehensive Testing', () => {
+  // ============================================================================
+  // BASIC PURITY TESTS
+  // ============================================================================
+
+  describe('calculateTotal', () => {
+    it('calculates total with tax', () => {
+      expect(calculateTotal(100, 0.1)).toBe(110)
+      expect(calculateTotal(50, 0.2)).toBe(60)
+    })
+
+    it('handles zero price', () => {
+      expect(calculateTotal(0, 0.1)).toBe(0)
+    })
+
+    it('handles zero tax rate', () => {
+      expect(calculateTotal(100, 0)).toBe(100)
+    })
+  })
+
+  describe('createTaxCalculator', () => {
+    it('creates specialized calculator', () => {
+      const calc = createTaxCalculator(0.1)
+      expect(calc(100)).toBe(110)
+      expect(calc(50)).toBe(55)
+    })
+  })
+
+  // ============================================================================
+  // VALIDATION TESTS (All Edge Cases)
+  // ============================================================================
+
+  describe('validateRequired', () => {
+    it('validates non-empty values', () => {
+      expect(validateRequired('test')).toBe(true)
+      expect(validateRequired(0)).toBe(true)
+      expect(validateRequired(false)).toBe(true)
+    })
+
+    it('rejects empty values', () => {
+      expect(validateRequired('')).toBe(false)
+      expect(validateRequired(null)).toBe(false)
+      expect(validateRequired(undefined)).toBe(false)
+    })
+  })
+
+  describe('validateEmail', () => {
+    it('validates correct emails', () => {
+      expect(validateEmail('test@example.com')).toBe(true)
+      expect(validateEmail('user.name@domain.co.uk')).toBe(true)
+    })
+
+    it('rejects invalid emails', () => {
+      expect(validateEmail('invalid')).toBe(false)
+      expect(validateEmail('missing@domain')).toBe(false)
+      expect(validateEmail('@example.com')).toBe(false)
+    })
+  })
+
+  describe('validateUserEmail - Composition', () => {
+    it('validates complete email', () => {
+      const result = validateUserEmail('test@example.com')
+      expect(result.valid).toBe(true)
+      expect(result.value).toBe('test@example.com')
+    })
+
+    it('rejects missing email', () => {
+      const result = validateUserEmail('')
+      expect(result.valid).toBe(false)
+      expect(result.error).toBe('Email is required')
+    })
+
+    it('rejects invalid format', () => {
+      const result = validateUserEmail('invalid')
+      expect(result.valid).toBe(false)
+      expect(result.error).toBe('Invalid email format')
+    })
+
+    it('rejects too short', () => {
+      const result = validateUserEmail('a@b')
+      expect(result.valid).toBe(false)
+      expect(result.error).toBe('Email must be 5-100 characters')
+    })
+
+    it('rejects too long', () => {
+      const longEmail = 'a'.repeat(100) + '@example.com'
+      const result = validateUserEmail(longEmail)
+      expect(result.valid).toBe(false)
+      expect(result.error).toBe('Email must be 5-100 characters')
+    })
+  })
+
+  // ============================================================================
+  // IMMUTABILITY TESTS
+  // ============================================================================
+
+  describe('Immutable Array Operations', () => {
+    const users = [
+      { id: 1, name: 'Alice', active: true },
+      { id: 2, name: 'Bob', active: false }
+    ]
+
+    describe('addUser', () => {
+      it('adds user without mutation', () => {
+        const newUser = { id: 3, name: 'Charlie', active: true }
+        const result = addUser(users, newUser)
+
+        expect(result).toHaveLength(3)
+        expect(result[2]).toEqual(newUser)
+        expect(users).toHaveLength(2) // Original unchanged
+      })
+    })
+
+    describe('removeUser', () => {
+      it('removes user without mutation', () => {
+        const result = removeUser(users, 1)
+
+        expect(result).toHaveLength(1)
+        expect(result[0].id).toBe(2)
+        expect(users).toHaveLength(2) // Original unchanged
+      })
+    })
+
+    describe('updateUser', () => {
+      it('updates user without mutation', () => {
+        const result = updateUser(users, 1, { name: 'Alice Updated' })
+
+        expect(result[0].name).toBe('Alice Updated')
+        expect(users[0].name).toBe('Alice') // Original unchanged
+      })
+
+      it('returns same array if user not found', () => {
+        const result = updateUser(users, 999, { name: 'Not Found' })
+
+        expect(result).toHaveLength(2)
+        expect(result).toEqual(users)
+      })
+    })
+  })
+
+  // ============================================================================
+  // ERROR HANDLING TESTS
+  // ============================================================================
+
+  describe('divide', () => {
+    it('divides numbers successfully', () => {
+      const result = divide(10, 2)
+      expect(result.success).toBe(true)
+      expect(result.data).toBe(5)
+    })
+
+    it('handles division by zero', () => {
+      const result = divide(10, 0)
+      expect(result.success).toBe(false)
+      expect(result.error).toBe('Division by zero')
+    })
+  })
+
+  describe('calculate - Chained Operations', () => {
+    it('calculates successfully', () => {
+      const result = calculate(20, 2, 5)
+      expect(result.success).toBe(true)
+      expect(result.data).toBe(2) // (20 / 2) / 5 = 2
+    })
+
+    it('short-circuits on first error', () => {
+      const result = calculate(20, 0, 5)
+      expect(result.success).toBe(false)
+      expect(result.error).toBe('Division by zero')
+    })
+
+    it('short-circuits on second error', () => {
+      const result = calculate(20, 2, 0)
+      expect(result.success).toBe(false)
+      expect(result.error).toBe('Division by zero')
+    })
+  })
+
+  // ============================================================================
+  // SYSTEMATIC EDGE CASE TESTING
+  // ============================================================================
+
+  describe('Edge Cases - All JavaScript Types', () => {
+    const allTypes = [
+      null,
+      undefined,
+      true,
+      false,
+      0,
+      1,
+      -1,
+      '',
+      'string',
+      [],
+      [1, 2],
+      {},
+      { key: 'value' },
+      NaN,
+      Infinity,
+      -Infinity
+    ]
+
+    describe('validateRequired - handles all types', () => {
+      allTypes.forEach(input => {
+        it(`handles ${typeof input}: ${JSON.stringify(input)}`, () => {
+          expect(() => validateRequired(input)).not.toThrow()
+        })
+      })
+    })
+  })
+
+  // ============================================================================
+  // MEMOIZATION TESTS
+  // ============================================================================
+
+  describe('memoize', () => {
+    it('caches results', () => {
+      const expensive = jest.fn((n) => n * 2)
+      const memoized = memoize(expensive)
+
+      expect(memoized(5)).toBe(10)
+      expect(expensive).toHaveBeenCalledTimes(1)
+
+      expect(memoized(5)).toBe(10)
+      expect(expensive).toHaveBeenCalledTimes(1) // Still 1, cached
+
+      expect(memoized(10)).toBe(20)
+      expect(expensive).toHaveBeenCalledTimes(2) // New input
+    })
+
+    it('works with multiple arguments', () => {
+      const add = jest.fn((a, b) => a + b)
+      const memoized = memoize(add)
+
+      expect(memoized(2, 3)).toBe(5)
+      expect(add).toHaveBeenCalledTimes(1)
+
+      expect(memoized(2, 3)).toBe(5)
+      expect(add).toHaveBeenCalledTimes(1) // Cached
+    })
+  })
+})

package/plugins/ima-claude/skills/js-fp/references/anti-patterns.md

@@ -0,0 +1,120 @@
+# Anti-Patterns Reference
+
+Common FP anti-patterns to avoid.
+
+## 1. Impure Functions Disguised as Pure
+
+```javascript
+// ANTI-PATTERN: Hidden mutation
+function processUser(user) {
+    user.lastProcessed = new Date() // Mutation!
+    return validateUser(user)
+}
+
+// CORRECT: Returns new object
+function processUser(user) {
+    return {
+        ...user,
+        lastProcessed: new Date()
+    }
+}
+```
+
+## 2. Configuration in Hot Paths
+
+```javascript
+// ANTI-PATTERN: O(records x fields) - schema accessed every iteration
+function processRecords(records, schema) {
+    return records.map(record => {
+        return schema.fields.reduce((obj, field) => {
+            obj[field.name] = transformField(record[field.name], field.type)
+            return obj
+        }, {})
+    })
+}
+
+// CORRECT: Pre-compile the transformation
+function createRecordProcessor(schema) {
+    const transformers = schema.fields.map(field =>
+        value => transformField(value, field.type)
+    )
+    return record => transformers.reduce((obj, transform, i) => {
+        obj[schema.fields[i].name] = transform(record[schema.fields[i].name])
+        return obj
+    }, {})
+}
+const processor = createRecordProcessor(schema) // Setup once
+const results = records.map(processor) // Fast execution
+```
+
+## 3. Over-Engineering Simple Cases
+
+```javascript
+// ANTI-PATTERN: Complex machinery for simple validation
+const validateEmail = createAdvancedValidator({
+    type: 'email',
+    rules: [createRule('format', emailRegex), createRule('length', {min: 5, max: 254})],
+    transformers: [createTransformer('lowercase'), createTransformer('trim')]
+})
+
+// CORRECT: Simple, direct approach
+const validateEmail = (email) => {
+    const trimmed = email.trim().toLowerCase()
+    return trimmed.length >= 5 && trimmed.length <= 254 && emailRegex.test(trimmed)
+}
+```
+
+## 4. Inline Validation Mixed with Business Logic
+
+```javascript
+// ANTI-PATTERN
+if (!body || !body.email) {
+  return errorResponse(c, 400, 'Email is required')
+}
+// ... more business logic
+
+// CORRECT: Separate validation function
+const validateAuthRequest = (body) => {
+  if (!body || !body.email) throw new ValidationError('Email is required')
+  return { email: body.email }
+}
+```
+
+## 5. Per-Request Service Instantiation
+
+```javascript
+// ANTI-PATTERN
+authRoutes.post('/request', async (c) => {
+  const authService = new AuthService(env)  // Created every request!
+  // ...
+})
+
+// CORRECT: Middleware DI or service container
+app.use(ctx => { ctx.authService = authService })  // Created once
+```
+
+## 6. Creating Custom FP Utilities
+
+> **Note**: This is about not CREATING your own FP utilities. Using established libraries (lodash, Ramda, etc.) is perfectly fine.
+
+```javascript
+// ANTI-PATTERN: Creating your own pipe/compose/curry utilities
+const pipe = (...fns) => x => fns.reduce((v, f) => f(v), x)
+const compose = (...fns) => x => fns.reduceRight((v, f) => f(v), x)
+
+// CORRECT: Native function calls with early returns
+const validateUser = (userData) => {
+  const requiredCheck = validateRequired(['email', 'name'])(userData)
+  if (!requiredCheck.valid) return requiredCheck
+  return validateEmail(userData)
+}
+```
+
+## Quick Checklist
+
+- [ ] No hidden mutations in function bodies
+- [ ] Configuration accessed once, not per-item
+- [ ] Complexity matches the problem size
+- [ ] Validation separated from business logic
+- [ ] Services instantiated once, injected via context
+- [ ] No custom FP utility functions (pipe, compose, curry)