gsd-pi 2.28.0 → 2.29.0-dev.23d50d0

package/dist/resources/skills/code-optimizer/SKILL.md

@@ -0,0 +1,160 @@
+---
+name: code-optimizer
+description: >
+  Deep code optimization audit using parallel specialist agents. Each agent hunts for performance
+  anti-patterns, inefficiencies, and suboptimal code using pattern-based detection (Grep/Glob)
+  WITHOUT reading the full source code first — avoiding anchoring bias on existing implementations.
+  Covers ALL optimization domains: database queries, memory leaks, algorithmic complexity,
+  concurrency, bundle size, dead code, I/O & network, rendering/UI, data structures,
+  error handling, caching, build config, security-performance, logging, and infrastructure.
+  Use when asked to: "optimize my code", "find performance issues", "audit code quality",
+  "speed up my app", "find bottlenecks", "code review for performance", "find anti-patterns",
+  "improve code efficiency", "reduce latency", "optimize performance", "code smell detection",
+  "find slow code", "optimize this project", "performance audit", "code optimization".
+  Also triggers on: "optimizar codigo", "encontrar cuellos de botella", "mejorar rendimiento".
+---
+
+# Code Optimizer
+
+Parallel multi-agent code optimization audit. Spawn 13 specialist agents simultaneously, each
+hunting for a different class of performance problem using pattern-based detection.
+
+## Critical Principle: No Code Reading Before Analysis
+
+Agents MUST NOT read source files before searching for patterns. Reading the code first causes
+anchoring bias — the agent accepts the existing implementation as "reasonable" and misses
+better alternatives. Instead, each agent:
+
+1. Read its assigned reference file from `references/` to load detection patterns
+2. Use Grep/Glob to scan the codebase for anti-patterns
+3. For each finding, ONLY THEN read the surrounding context (5-10 lines) to confirm the issue
+4. Propose the optimal solution based on best practices, NOT based on the existing code
+
+## Workflow
+
+### Step 1: Detect Stack
+
+Use Glob to identify the project's tech stack:
+- `**/package.json` → Node.js/JS/TS (check for React, Next.js, Express, etc.)
+- `**/requirements.txt`, `**/pyproject.toml`, `**/setup.py` → Python
+- `**/go.mod` → Go
+- `**/Cargo.toml` → Rust
+- `**/pom.xml`, `**/build.gradle` → Java
+- `**/Gemfile` → Ruby
+- `**/Dockerfile` → Docker
+- `**/*.sql` → SQL
+- `**/webpack.config.*`, `**/vite.config.*`, `**/tsconfig.json` → Build tools
+
+### Step 2: Spawn 13 Parallel Agents
+
+Launch ALL agents simultaneously using the Agent tool. Each agent receives:
+- Its domain name and reference file path
+- The detected tech stack (so it can focus on relevant patterns)
+- The project root path
+- Instructions to NOT read code files, only Grep/Glob for patterns
+
+**Agent definitions** (spawn all 13 in a single message):
+
+| # | Agent Name | Reference File | Focus |
+|---|-----------|----------------|-------|
+| 1 | Database & Queries | `references/database-queries.md` | N+1 queries, SELECT *, missing indexes, ORM misuse, connection pooling |
+| 2 | Memory & Resources | `references/memory-resources.md` | Memory leaks, unclosed resources, large allocations, string concat in loops |
+| 3 | Algorithmic Complexity | `references/algorithmic-complexity.md` | O(n^2) patterns, unnecessary iterations, wrong data structures for lookups |
+| 4 | Concurrency & Async | `references/concurrency-async.md` | Sequential awaits, blocking in async, race conditions, unbounded concurrency |
+| 5 | Bundle & Dependencies | `references/bundle-dependencies.md` | Heavy imports, unused deps, duplicate libs, missing lazy loading |
+| 6 | Dead Code & Redundancy | `references/dead-code-redundancy.md` | Unused exports, commented code, dead branches, duplicate logic |
+| 7 | I/O & Network | `references/io-network.md` | Sequential requests, missing batching, no dedup, missing compression |
+| 8 | Rendering & UI | `references/rendering-ui.md` | Re-renders, missing virtualization, layout thrashing, animation perf |
+| 9 | Data Structures | `references/data-structures.md` | Wrong structures, unnecessary copies, inefficient serialization |
+| 10 | Error & Resilience | `references/error-resilience.md` | Missing timeouts, swallowed errors, no retries, no circuit breakers |
+| 11 | Caching & Memoization | `references/caching-memoization.md` | Missing memoization, cache without invalidation, redundant API calls |
+| 12 | Build & Compilation | `references/build-compilation.md` | Dev code in prod, missing optimization flags, slow tests, Docker issues |
+| 13 | Security-Performance | `references/security-performance.md` | Crypto misuse, missing rate limiting, ReDoS, SQL injection vectors |
+
+**Optional agents** (spawn if relevant to detected stack):
+- Logging & Observability (`references/logging-observability.md`) — if logging framework detected
+- Config & Infrastructure (`references/config-infra.md`) — if Docker/deployment config detected
+
+### Agent Prompt Template
+
+Each agent MUST receive this prompt structure:
+
+```
+You are a {DOMAIN_NAME} optimization specialist. Your job is to find performance
+anti-patterns in the codebase at {PROJECT_ROOT}.
+
+CRITICAL RULES:
+1. DO NOT read source code files before searching. This avoids anchoring bias.
+2. First, read your reference file: {SKILL_DIR}/references/{REFERENCE_FILE}
+3. Use Grep and Glob to search for the patterns described in the reference file.
+4. Only read 5-10 lines of context around each finding to confirm it's a real issue.
+5. Skip patterns that don't match the project's stack: {DETECTED_STACK}
+
+Tech stack detected: {DETECTED_STACK}
+Project root: {PROJECT_ROOT}
+
+For each finding, report:
+- **File**: path:line_number
+- **Pattern**: what anti-pattern was detected
+- **Severity**: CRITICAL / HIGH / MEDIUM / LOW
+- **Current code**: the problematic snippet (keep short)
+- **Why it's slow**: brief explanation of the performance impact
+- **Optimal fix**: the recommended solution (code snippet or approach)
+- **Estimated impact**: qualitative improvement expected (e.g., "10x faster for large lists")
+
+If you find 0 issues in your domain, report "No issues found" — this is a valid outcome.
+Sort findings by severity (CRITICAL first).
+```
+
+### Step 3: Consolidate Report
+
+After all agents complete, consolidate their findings into a single prioritized report:
+
+1. Collect all findings from all agents
+2. Deduplicate (different agents may flag the same code for different reasons)
+3. Sort by severity: CRITICAL > HIGH > MEDIUM > LOW
+4. Group by file (so the user can fix file-by-file)
+5. Present the final report with:
+   - Executive summary: total findings by severity, top 3 most impactful
+   - Detailed findings table grouped by file
+   - Improvement plan: ordered list of fixes from highest to lowest impact
+
+### Report Format
+
+```markdown
+# Code Optimization Audit Report
+
+## Executive Summary
+- **X** critical issues, **Y** high, **Z** medium, **W** low
+- Top 3 highest-impact fixes:
+  1. [brief description] — [estimated impact]
+  2. [brief description] — [estimated impact]
+  3. [brief description] — [estimated impact]
+
+## Findings by File
+
+### `path/to/file.ts`
+
+| # | Severity | Domain | Pattern | Fix | Impact |
+|---|----------|--------|---------|-----|--------|
+| 1 | CRITICAL | Database | N+1 query in loop | Use prefetch_related | 50x fewer queries |
+| 2 | HIGH | Async | Sequential awaits | Use Promise.all | 3x faster |
+
+[... for each file with findings ...]
+
+## Improvement Plan
+
+Priority-ordered steps to implement the fixes:
+
+1. **[CRITICAL] Fix N+1 queries in `api/users.py`**
+   - Current: loop queries user.posts for each user
+   - Fix: add prefetch_related('posts') to queryset
+   - Impact: reduces N+1 to 2 queries
+
+2. **[HIGH] Parallelize API calls in `services/sync.ts`**
+   - Current: 5 sequential await fetch() calls
+   - Fix: Promise.all([fetch1, fetch2, ...])
+   - Impact: ~5x faster sync operation
+
+[... continue for all findings ...]
+```

package/dist/resources/skills/code-optimizer/references/algorithmic-complexity.md

@@ -0,0 +1,66 @@
+# Algorithmic Complexity
+
+## Grep/Glob Patterns to Detect
+
+### O(n^2) and Worse Patterns
+```
+# Nested loops over same/related collections
+for.*in.*\n.*for.*in         (nested for loops)
+\.forEach\(.*\.forEach\(      (nested forEach)
+\.map\(.*\.map\(              (nested map)
+\.filter\(.*\.includes\(      (filter+includes = O(n*m))
+\.find\(.*inside.*\.map\(     (find inside map)
+\.indexOf\(.*inside.*for      (indexOf in loop)
+\.includes\(.*inside.*for     (includes in loop)
+# Array as lookup table
+array\.find\(.*===            (use Map/Set instead)
+array\.some\(.*===            (use Set.has instead)
+list\.index\(                 (Python: use dict instead)
+if.*in\s+list                 (Python: O(n) lookup in list)
+```
+
+### Unnecessary Iterations
+```
+\.filter\(.*\.length          (filter just to count)
+\.filter\(.*\[0\]             (filter just to get first - use find)
+\.map\(.*\.filter\(           (map then filter - combine or reverse order)
+\.filter\(.*\.map\(.*\.filter (multiple passes when one suffices)
+\.sort\(\).*\[0\]             (sort to get min/max - use Math.min/max or reduce)
+\.sort\(\).*\.slice\(0        (sort to get top-k - use partial sort/heap)
+sorted\(.*\)\[0\]             (Python: use min() instead)
+sorted\(.*\)\[-1\]            (Python: use max() instead)
+\.reverse\(\).*\.forEach      (reverse just to iterate backwards)
+Object\.keys\(.*\.map\(.*Object\.values  (iterating keys then accessing values)
+```
+
+### Redundant Computation
+```
+# Same computation in loop
+for.*\n.*Math\.              (math operations that could be hoisted)
+for.*\n.*\.length            (accessing .length repeatedly - may be fine, check)
+for.*\n.*document\.querySelector  (DOM queries in loops)
+for.*\n.*JSON\.parse         (parsing same JSON repeatedly)
+for.*\n.*new RegExp\(        (creating regex in loop)
+for.*\n.*new Date\(          (creating Date objects in loop for same date)
+```
+
+### Inefficient Data Structure Choice
+```
+# Using arrays where Set/Map would be better
+\.push\(.*\.includes\(       (array as unique set)
+\.filter\(.*\.indexOf\(       (dedup with filter+indexOf)
+\[\].*\.find\(               (array for lookups)
+# Using objects where Map would be better
+\{\}.*\[.*\]\s*=             (frequent dynamic key insertion)
+delete.*\[                   (frequent key deletion from object)
+```
+
+## Improvement Strategies
+
+1. **Nested loops**: Pre-build lookup Map/Set, use hash-based approaches
+2. **Filter+includes**: Convert one collection to Set for O(1) lookups
+3. **Sort for min/max**: Use Math.min/max, reduce, or heap for top-k
+4. **Multiple passes**: Combine into single reduce/loop
+5. **Redundant computation**: Hoist invariants out of loops, memoize
+6. **Array as lookup**: Use Map for key-value, Set for existence checks
+7. **String matching in loops**: Pre-compile regex, use Map for exact matches

package/dist/resources/skills/code-optimizer/references/build-compilation.md

@@ -0,0 +1,90 @@
+# Build & Compilation Optimization
+
+## Grep/Glob Patterns to Detect
+
+### Unoptimized Build Config
+```
+# Webpack
+mode:\s*['"]development['"]        (dev mode in production build)
+devtool:\s*['"]source-map['"]      (full source maps in production)
+devtool:\s*['"]eval                (eval source maps in production)
+# No code splitting
+splitChunks.*false                  (code splitting disabled)
+# No minification
+minimize:\s*false                   (minification disabled)
+# Missing tree shaking
+sideEffects.*true                   (prevents tree shaking)
+```
+
+### Development-Only Code in Production
+```
+console\.log\(                     (debug logging)
+console\.debug\(                   (debug logging)
+console\.trace\(                   (trace logging)
+debugger;                           (debugger statement)
+\.only\(                           (test.only left in)
+\.skip\(                           (test.skip left in)
+if\s*\(.*process\.env\.NODE_ENV.*development  (dev-only code)
+__DEV__                             (React Native dev flag)
+```
+
+### Missing Optimization Flags
+```
+# TypeScript
+"strict":\s*false                  (strict mode disabled)
+"skipLibCheck":\s*false            (slow lib checking)
+"incremental":\s*false             (no incremental compilation)
+# Python
+python\s+-O                        (check if optimized flag used)
+__debug__                           (debug-only code)
+# Docker
+FROM.*:latest                      (unpinned base image)
+RUN.*pip install(?!.*--no-cache)   (pip without --no-cache-dir)
+RUN.*npm install(?!.*--production) (npm install without --production)
+COPY\s+\.\s+\.                     (copying entire context)
+```
+
+### Large/Slow Imports at Startup
+```
+# Top-level heavy imports that could be lazy
+import.*tensorflow                  (heavy ML library at top)
+import.*pandas                      (heavy data library at top)
+import.*matplotlib                  (heavy viz library at top)
+import.*scipy                       (heavy math library at top)
+from.*import\s+\*                   (wildcard imports slow startup)
+# Circular imports
+ImportError.*circular               (circular import errors)
+```
+
+### Missing Caching in CI/CD
+```
+# No caching steps
+npm install(?!.*cache)              (npm install without cache)
+pip install(?!.*cache)              (pip install without cache)
+go build(?!.*cache)                 (go build without cache)
+docker build(?!.*cache)             (docker build without layer cache)
+```
+
+### Slow Test Suite
+```
+# Real I/O in tests
+fetch\(.*test                       (real network calls in tests)
+requests\.\w+\(.*test              (real HTTP in Python tests)
+open\(.*test                        (real file I/O in tests)
+# No test parallelization
+--runInBand                         (Jest sequential mode)
+-p no:xdist                         (pytest parallelization disabled)
+# Heavy setup/teardown
+beforeAll.*database                 (real DB setup in tests)
+setUp.*database                     (real DB in Python tests)
+```
+
+## Improvement Strategies
+
+1. **Build config**: Ensure production mode, minification, tree shaking, code splitting
+2. **Dev code**: Strip console.log/debugger via build plugin (e.g., babel-plugin-transform-remove-console)
+3. **TypeScript**: Enable strict, incremental, skipLibCheck for faster builds
+4. **Docker**: Multi-stage builds, .dockerignore, layer caching, pinned versions
+5. **Lazy imports**: Move heavy imports to function scope where they're needed
+6. **CI caching**: Cache node_modules, pip cache, go build cache, Docker layers
+7. **Test speed**: Mock I/O, run tests in parallel, use in-memory DBs for integration tests

package/dist/resources/skills/code-optimizer/references/bundle-dependencies.md

@@ -0,0 +1,82 @@
+# Bundle Size & Dependencies
+
+## Grep/Glob Patterns to Detect
+
+### Heavy Imports
+```
+import\s+\w+\s+from\s+['"]lodash['"]      (full lodash import vs lodash/specific)
+import\s+\w+\s+from\s+['"]moment['"]      (moment.js - use date-fns/dayjs)
+import\s+\w+\s+from\s+['"]underscore['"]  (underscore - mostly native now)
+import\s+\*\s+as                           (wildcard imports prevent tree-shaking)
+require\(['"]lodash['"]\)                   (CJS lodash import)
+from\s+pandas\s+import\s+\*                (full pandas import)
+import\s+tensorflow                         (full TF import)
+import\s+boto3                              (full AWS SDK)
+```
+
+### Unused Dependencies
+```
+# Check package.json dependencies vs actual imports
+# Check requirements.txt vs actual imports
+# Check go.mod vs actual imports
+import.*from.*['"](\w+)['"]   (cross-reference with package.json)
+```
+
+### Duplicate Functionality
+```
+# Multiple date libraries
+moment.*\n.*date-fns          (both moment and date-fns)
+moment.*\n.*dayjs             (both moment and dayjs)
+# Multiple HTTP clients
+axios.*\n.*node-fetch         (both axios and fetch)
+axios.*\n.*got                (both axios and got)
+# Multiple utility libraries
+lodash.*\n.*underscore        (both lodash and underscore)
+# Multiple state managers
+redux.*\n.*mobx               (both redux and mobx)
+zustand.*\n.*jotai            (multiple state libs)
+```
+
+### Dev Dependencies in Production
+```
+# devDependencies imported in src/
+import.*from.*['"](@testing|jest|mocha|chai|sinon|cypress|storybook)
+# Debug/test code in production
+console\.log\(
+console\.debug\(
+debugger;
+\.only\(         (test.only left in)
+```
+
+### Dynamic Imports Missing
+```
+# Large components imported statically that could be lazy
+import.*Modal       (modals are great candidates for lazy loading)
+import.*Chart       (charts are heavy)
+import.*Editor      (rich editors are heavy)
+import.*PDF         (PDF libs are heavy)
+import.*Map         (map components are heavy)
+# Route-level components not lazy loaded
+import.*Page.*from  (page components should often be lazy)
+```
+
+### Large Assets
+```
+# Check for unoptimized assets
+\.png['"]          (check if could be webp/avif)
+\.jpg['"]          (check if could be webp/avif)
+\.gif['"]          (check if could be video/webp)
+\.svg['"].*import  (SVGs imported as modules - check size)
+base64             (inline base64 assets)
+data:image         (inline images)
+```
+
+## Improvement Strategies
+
+1. **Lodash**: Use `lodash-es/specific` or native equivalents (Array.find, Object.entries, etc.)
+2. **Moment.js**: Replace with date-fns or dayjs (10x smaller)
+3. **Wildcard imports**: Use named imports for tree-shaking
+4. **Unused deps**: Remove from package.json/requirements.txt
+5. **Dynamic imports**: Use React.lazy/import() for heavy, below-fold components
+6. **Images**: Convert to WebP/AVIF, use responsive srcset, lazy load below-fold
+7. **Duplicate libs**: Consolidate to one library per concern

package/dist/resources/skills/code-optimizer/references/caching-memoization.md

@@ -0,0 +1,76 @@
+# Caching & Memoization
+
+## Grep/Glob Patterns to Detect
+
+### Missing Memoization
+```
+# Expensive computations without caching
+def\s+\w+\(.*\).*:\s*\n.*for.*for      (Python: expensive function without @lru_cache)
+function\s+\w+\(.*\).*\{.*for.*for     (JS: expensive function without memoization)
+# React missing useMemo/useCallback
+const\s+\w+\s*=\s*\w+\.filter\(        (derived data on every render)
+const\s+\w+\s*=\s*\w+\.map\(           (derived data on every render)
+const\s+\w+\s*=\s*\w+\.reduce\(        (derived data on every render)
+const\s+\w+\s*=\s*\w+\.sort\(          (sorting on every render)
+# Same computation called multiple times
+(\w+)\(same_args\).*\1\(same_args\)    (same function, same args, called twice)
+```
+
+### Cache Without Invalidation
+```
+cache\s*=\s*\{\}                        (cache without TTL or max size)
+_cache\s*=\s*\{\}                       (module cache without eviction)
+memo\s*=\s*\{\}                         (memo without invalidation)
+\.cache\s*=\s*\{\}                      (instance cache without cleanup)
+CACHE_TTL.*=.*(?:86400|3600.*24)       (very long TTL - stale data risk)
+```
+
+### Redundant API/DB Calls
+```
+# Same query executed multiple times
+\.query\(.*same.*\.query\(             (duplicate queries)
+fetch\(['"]same_url['"]\).*fetch\(     (duplicate fetches)
+# No SWR/stale-while-revalidate
+useEffect\(.*fetch\(.*\[\]            (fetch on every mount without caching)
+useEffect\(.*axios\.\w+\(.*\[\]       (API call on every mount)
+componentDidMount.*fetch               (fetch without caching layer)
+```
+
+### Over-Caching
+```
+# Caching things that change frequently
+cache.*user.*session                   (caching session-specific data)
+cache.*real.?time                      (caching real-time data)
+cache.*current.*time                   (caching time-dependent data)
+# Caching large objects
+cache\[.*\]\s*=\s*.*large             (large objects in cache)
+```
+
+### Missing HTTP Caching
+```
+# API responses without cache headers
+res\.json\(                            (check if Cache-Control is set)
+return\s+Response\(                    (check if cache headers are set)
+return\s+JsonResponse\(               (Django: check cache headers)
+# Static assets without long cache
+express\.static\(                      (check maxAge setting)
+nginx.*location.*static               (check expires/cache-control)
+```
+
+### Computed Properties Recalculated
+```
+# Getters that compute on every access
+get\s+\w+\(\)\s*\{.*return.*\.filter   (getter computing on each access)
+get\s+\w+\(\)\s*\{.*return.*\.map      (getter computing on each access)
+@property\s*\n\s*def.*\n.*for          (Python property computing in loop)
+```
+
+## Improvement Strategies
+
+1. **Memoization**: Use @lru_cache (Python), useMemo/useCallback (React), _.memoize (JS)
+2. **Cache invalidation**: Always set TTL and max size; prefer LRU eviction
+3. **API caching**: Use SWR/React Query for client, Redis/Memcached for server
+4. **HTTP caching**: Set Cache-Control headers, use ETags, stale-while-revalidate
+5. **Computed properties**: Cache results with dirty flag or use memoized selectors (reselect)
+6. **Request deduplication**: Deduplicate identical in-flight requests
+7. **Multi-level cache**: L1 (in-memory) -> L2 (Redis) -> L3 (DB) for read-heavy workloads

package/dist/resources/skills/code-optimizer/references/concurrency-async.md

@@ -0,0 +1,80 @@
+# Concurrency & Async Patterns
+
+## Grep/Glob Patterns to Detect
+
+### Sequential Async (Should Be Parallel)
+```
+await.*\n.*await.*\n.*await    (multiple sequential awaits that could be parallel)
+for.*await                      (sequential await in loop)
+\.then\(.*\.then\(.*\.then\(   (promise chain that could be Promise.all)
+# Python
+await.*\n.*await.*\n.*await    (sequential awaits)
+for.*in.*:\n.*await            (await in loop)
+```
+
+### Missing Parallelization
+```
+# Should use Promise.all / asyncio.gather
+fetch\(.*\n.*fetch\(           (sequential fetches)
+axios\.\w+\(.*\n.*axios\.     (sequential HTTP calls)
+requests\.\w+\(.*\n.*requests\. (Python sequential requests)
+```
+
+### Blocking Operations in Async Context
+```
+# Node.js sync operations in async code
+fs\.readFileSync               (blocking file read)
+fs\.writeFileSync              (blocking file write)
+fs\.existsSync                 (blocking existence check)
+child_process\.execSync        (blocking exec)
+\.readFileSync\(               (any sync file operation)
+# Python blocking in async
+time\.sleep\(                  (use asyncio.sleep instead)
+requests\.                     (use aiohttp/httpx instead)
+open\(.*\.read\(\)            (use aiofiles instead)
+os\.path\.exists               (use aio equivalent)
+```
+
+### Race Conditions & Thread Safety
+```
+# Shared mutable state
+global\s+\w+.*=               (Python global mutation)
+threading\.Thread.*shared      (shared state across threads)
+# Missing locks
+\.append\(.*thread             (list append without lock)
+\+=.*without.*lock             (increment without lock)
+# JavaScript
+let\s+\w+.*=.*\n.*async       (mutable let used in async)
+```
+
+### Unbounded Concurrency
+```
+# No concurrency limit
+\.map\(.*fetch                 (unbounded parallel fetches)
+\.map\(.*axios                 (unbounded parallel requests)
+Promise\.all\(.*\.map\(        (all items in parallel, no limit)
+asyncio\.gather\(.*for         (all coroutines at once)
+# Missing backpressure
+while.*true.*await             (infinite async loop without backpressure)
+```
+
+### Error Handling in Async
+```
+# Unhandled rejections
+\.then\(.*without.*\.catch     (promise without catch)
+async.*without.*try.*catch     (async without error handling)
+# Swallowed errors
+catch\s*\(\s*\)\s*\{          (empty catch block)
+except:\s*$                    (bare except)
+except\s+Exception\s*:.*pass  (catch-all with pass)
+```
+
+## Improvement Strategies
+
+1. **Sequential awaits**: Use Promise.all/allSettled, asyncio.gather for independent operations
+2. **Await in loops**: Batch with Promise.all or use p-limit for controlled concurrency
+3. **Blocking in async**: Replace sync APIs with async equivalents
+4. **Race conditions**: Use locks, atomic operations, or immutable patterns
+5. **Unbounded concurrency**: Use semaphores, p-limit, connection pools
+6. **Error handling**: Always catch async errors, use Promise.allSettled for partial failure tolerance
+7. **Backpressure**: Use queues, streaming, or batching for producer-consumer patterns

package/dist/resources/skills/code-optimizer/references/config-infra.md

@@ -0,0 +1,71 @@
+# Configuration & Infrastructure Inefficiencies
+
+## Grep/Glob Patterns to Detect
+
+### Missing Connection Pooling
+```
+# New connection per request
+create_engine\(.*(?!.*pool)        (SQLAlchemy without pool config)
+new Pool\(.*(?!.*max)              (pg Pool without max connections)
+mongoose\.connect\(.*(?!.*pool)    (Mongoose without pool)
+DriverManager\.getConnection\(     (Java: new connection per call)
+psycopg2\.connect\(.*(?!.*pool)   (psycopg2 without pool)
+redis\.createClient\(.*per.*request (new Redis client per request)
+```
+
+### Missing Environment-Based Config
+```
+hardcoded.*url                     (hardcoded URLs)
+['"]http://localhost               (hardcoded localhost URLs)
+['"]127\.0\.0\.1                   (hardcoded localhost IPs)
+password\s*=\s*['"]                (hardcoded passwords)
+api.?key\s*=\s*['"]               (hardcoded API keys)
+secret\s*=\s*['"]                  (hardcoded secrets)
+port\s*=\s*\d{4}                   (hardcoded port numbers)
+```
+
+### Missing Process Management
+```
+# Single-threaded Node.js without clustering
+app\.listen\(.*(?!.*cluster)       (Node without cluster module)
+# Python without proper WSGI/ASGI workers
+\.run\(.*debug=True                (Flask debug mode)
+uvicorn\.run\(.*workers=1          (single worker)
+gunicorn.*-w\s*1\b                 (single gunicorn worker)
+```
+
+### Docker/Container Issues
+```
+FROM.*:latest                      (unpinned image version)
+RUN.*apt-get.*&&.*apt-get         (check if apt cache is cleaned)
+COPY\s+\.\s+\.                     (copying entire context - no .dockerignore)
+RUN.*npm install\b(?!.*--production) (installing devDeps in production)
+RUN.*pip install\b(?!.*--no-cache) (pip without cache clearing)
+# Multiple RUN commands that should be combined
+RUN.*\nRUN.*\nRUN                  (multiple RUN layers)
+```
+
+### Missing Health Checks
+```
+# Services without health endpoints
+app\.(listen|start)\(.*(?!.*health) (server without health check)
+# Docker without HEALTHCHECK
+Dockerfile.*(?!.*HEALTHCHECK)       (Dockerfile without health check)
+```
+
+### Inefficient Polling
+```
+setInterval\(.*fetch               (polling instead of WebSocket/SSE)
+setInterval\(.*axios               (polling instead of push)
+while.*sleep.*fetch                 (polling loop)
+time\.sleep\(.*requests            (Python: polling with sleep)
+```
+
+## Improvement Strategies
+
+1. **Connection pooling**: Configure pool_size, max_overflow, pool_recycle
+2. **Environment config**: Use .env files, config libraries, never hardcode secrets
+3. **Process management**: Use cluster mode (Node), multiple workers (Python ASGI/WSGI)
+4. **Docker**: Multi-stage builds, .dockerignore, combine RUN layers, pin versions
+5. **Health checks**: Add /health endpoint, Docker HEALTHCHECK, readiness/liveness probes
+6. **Polling -> Push**: Use WebSocket, SSE, or long-polling instead of interval polling