Code Evolution Lab← Back to site

A comprehensive table of all issues detected by the Code Evolution Lab analysis engine.

These are the issue types emitted by the backend engine, which powers web and API scans. Severity, confidence, category, and fix difficulty come from each detector’s createImpact() call; where a row lists several values, the detector varies them by context.

Issue Type Severity Severity Score Description Confidence Score Category Fix Difficulty Detector
n_plus_1_query critical/high/medium 9/7/5 {queriesIfN100} queries for 100 items vs 1 optimal query 85 performance moderate N+1 Query
inefficient_array_chaining medium 5 ~50% faster for large arrays with single iteration 80 performance easy Inefficient Loop
nested_array_methods high 7 O(n²) complexity causes exponential slowdown 75 complexity moderate Inefficient Loop
array_push_in_loop low 3 Minor performance impact, better patterns available 60 performance easy Inefficient Loop
dom_manipulation_in_loop high 8 Multiple browser reflows cause severe UI jank 90 performance moderate Inefficient Loop
await_in_loop high 8 Sequential execution causes unnecessary delays 90 performance easy Inefficient Loop
string_concat_in_loop medium 5 Repeated string allocation causes memory churn 70 performance easy Inefficient Loop
regex_compilation_in_loop medium 5 Repeated regex compilation overhead 75 performance trivial Inefficient Loop
json_operations_in_loop high 7 Expensive serialization/deserialization overhead 85 performance easy Inefficient Loop
array_lookup_in_loop high 7 O(n²) complexity from nested array searches 85 complexity easy Inefficient Loop
nested_loops critical/high 9/7 O(n²) or O(n³) complexity causes exponential performance degradation 90 complexity complex/moderate Inefficient Loop
object_keys_with_lookup high 7 O(n²) from Object.keys + array search 80 complexity easy Inefficient Loop
sync_file_io_in_loop critical 9 Blocks event loop causing severe performance degradation 95 performance moderate Inefficient Loop
event_listener_leak high/medium 7 Memory leak in long-running applications 85/70 memory easy Memory Leak
timer_leak critical/high 9 Continuous memory growth and CPU usage 90/85 memory easy Memory Leak
global_variable_leak medium 5 Memory leaks and namespace pollution 65 memory moderate Memory Leak
closure_memory_leak medium 6 Prevents garbage collection of large objects 55 memory moderate Memory Leak
large_api_payload high 7 Large payloads impact performance and bandwidth 80 network easy Large Payload
select_all_query medium 5 Increased memory usage and slower queries 75 performance easy Large Payload
large_return_payload high 7 Memory overflow with large datasets 80 memory easy Large Payload
sync_file_operation critical/high/medium 9/8/6 Synchronous I/O blocks the event loop 90 performance easy Blocking I/O
sync_crypto_operation high/medium 8/6 CPU-intensive sync crypto blocks event loop 85 performance easy Blocking I/O
sync_child_process high 8 Sync child process blocks until completion 95 performance easy Blocking I/O
unawaited_network_call medium 5 Unawaited network calls can cause unexpected behavior 60 performance trivial Blocking I/O
sync_database_operation critical 9 Sync database calls block all concurrent operations 95 performance moderate Blocking I/O
sync_fs_import low 3 Sync imports suggest blocking code patterns 50 performance easy Blocking I/O
heavy_package_import medium 5 Large dependency increases bundle size 85 network moderate Bundle Size
namespace_import_treeshakable high 7 Namespace imports include entire package in bundle 90 network easy Bundle Size
unused_import medium 4 Unused imports increase bundle size 70 network trivial Bundle Size
partially_unused_import low 2 Unused named imports may increase bundle size 60 network trivial Bundle Size
dynamic_import_opportunity low 3 Static imports of conditionally-used code increase initial bundle 55 network moderate Bundle Size
multiple_subpath_imports low 2 Multiple subpath imports may indicate over-importing 50 network trivial Bundle Size
forced_synchronous_layout high 8 Layout thrashing causes severe jank 85 performance moderate DOM Manipulation
innerhtml_user_input critical 9 XSS vulnerability allows arbitrary code execution 90 performance moderate DOM Manipulation
document_write high 7 document.write blocks parsing 95 performance easy DOM Manipulation
dom_query_in_loop medium 5 Repeated DOM queries are expensive 80 performance trivial DOM Manipulation
repeated_expensive_call medium 5 Repeated expensive calls waste resources 75 performance trivial Missing Caching
missing_memoization medium 5 Repeated computation in hot path 70 performance easy Missing Caching
api_without_cache medium 5 Uncached API/DB calls in hot paths cause latency 60 network moderate Missing Caching
pure_function_no_memo low 3 Repeated pure function calls could be cached 50 performance easy Missing Caching
missing_database_index high/medium 7/5 Database queries without proper indexes cause full table scans 75/60 performance moderate Missing Index
raw_query_index_hint high/medium 7/5 Raw queries without proper indexes cause performance issues 65 performance moderate Missing Index
multiple_where_conditions high 7 Multiple conditions without composite index cause slow queries 70 performance moderate Missing Index
redos_vulnerability critical/high/medium 9/7/5 ReDoS can cause denial of service with malicious input 90/75/60 performance complex/moderate ReDoS
regex_user_input high 7 User input with complex regex can cause ReDoS 70 performance moderate ReDoS
unclosed_connection high 7 Unclosed connections cause resource exhaustion 75 memory moderate Resource Leaks
unclosed_stream high/medium 7/5 Unclosed streams leak file descriptors 70 memory easy Resource Leaks
unclosed_file_handle high 7 Unclosed file handles exhaust system resources 80 memory easy Resource Leaks
resource_without_cleanup medium 5 Resource instances should be properly cleaned up 65 memory easy Resource Leaks

Severity Levels

Severity Description
critical Immediate attention required. Severe performance degradation, security vulnerabilities, or resource exhaustion.
high Significant impact on performance, memory, or code quality. Should be addressed soon.
medium Moderate impact. Improvements will provide noticeable benefits.
low Minor issues. Fixing provides incremental improvements.

Categories

Category Description
performance Runtime performance, response times, or throughput issues.
memory Memory usage, leaks, or garbage collection pressure.
complexity Algorithmic complexity (e.g., O(n²) operations).
network Data transfer, bundle size, or API efficiency.

Fix Difficulty Levels

Difficulty Description
trivial Simple one-line changes. Minimal risk.
easy Straightforward changes with clear patterns. Low risk.
moderate Requires some refactoring or architectural consideration.
complex Significant changes required. May need careful testing.

Hand-maintained. The source of truth is the generator registration map in backend/src/analyzer/code-analyzer.ts — if an issue type is not registered there, it will not reach a solution generator. Verify against that file when adding or renaming a type.